Datasets:

oliveirabruno01

/

HVM_commits_data

like 0

ed218b4ecc1665909cf1383548377b561679ba16

change if to case on parseTopImp (style)

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.List (partition, isPrefixOf) import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : rest) -> do let (flags, strArgs) = partition ("-" `isPrefixOf`) rest let compiled = "-c" `elem` flags let collapse = "-C" `elem` flags let search = "-S" `elem` flags let stats = "-s" `elem` flags let debug = "-d" `elem` flags let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats strArgs ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [flags] [string args...] # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> [String] -> IO (Either String ()) cliRun filePath debug compiled mode showStats strArgs = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Abort when wrong number of strArgs let ((_, mainArgs), _) = mget (fidToFun book) (mget (namToFid book) "main") when (length strArgs /= length mainArgs) $ do putStrLn $ "Error: 'main' expects " ++ show (length mainArgs) ++ " arguments, found " ++ show (length strArgs) exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime -- Convert string arguments to Core terms and inject them at runtime let args = map (\str -> foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str) strArgs root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") args) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState case MS.lookup path (imported st) of Just _ -> return [] Nothing -> do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.List (partition, isPrefixOf) import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : rest) -> do let (flags, strArgs) = partition ("-" `isPrefixOf`) rest let compiled = "-c" `elem` flags let collapse = "-C" `elem` flags let search = "-S" `elem` flags let stats = "-s" `elem` flags let debug = "-d" `elem` flags let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats strArgs ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [flags] [string args...] # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> [String] -> IO (Either String ()) cliRun filePath debug compiled mode showStats strArgs = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Abort when wrong number of strArgs let ((_, mainArgs), _) = mget (fidToFun book) (mget (namToFid book) "main") when (length strArgs /= length mainArgs) $ do putStrLn $ "Error: 'main' expects " ++ show (length mainArgs) ++ " arguments, found " ++ show (length strArgs) exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime -- Convert string arguments to Core terms and inject them at runtime let args = map (\str -> foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str) strArgs root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") args) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

5cc00a09eb76ecc893c3b8cc9e70000d24c4ae7c

Inject cli args in runtime and not the AST to avoid invalidating cache

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.List (partition, isPrefixOf) import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : rest) -> do let (flags, strArgs) = partition ("-" `isPrefixOf`) rest let compiled = "-c" `elem` flags let collapse = "-C" `elem` flags let search = "-S" `elem` flags let stats = "-s" `elem` flags let debug = "-d" `elem` flags let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats strArgs ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [flags] [string args...] # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> [String] -> IO (Either String ()) cliRun filePath debug compiled mode showStats strArgs = do -- Initialize the HVM hvmInit code <- readFile filePath -- Wrap the main function with any cli arguments let codeA = code ++ "\n@__main = @main(" ++ unwords (map (\s -> "\"" ++ s ++ "\"") strArgs) ++ ")" book <- doParseBook codeA -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Abort when wrong number of strArgs let ((_, mainArgs), _) = mget (fidToFun book) (mget (namToFid book) "main") when (length strArgs /= length mainArgs) $ do putStrLn $ "Error: 'main' expects " ++ show (length mainArgs) ++ " arguments, found " ++ show (length strArgs) exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "__main" (mget (namToFid book) "__main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "__main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.List (partition, isPrefixOf) import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : rest) -> do let (flags, strArgs) = partition ("-" `isPrefixOf`) rest let compiled = "-c" `elem` flags let collapse = "-C" `elem` flags let search = "-S" `elem` flags let stats = "-s" `elem` flags let debug = "-d" `elem` flags let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats strArgs ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [flags] [string args...] # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> [String] -> IO (Either String ()) cliRun filePath debug compiled mode showStats strArgs = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Abort when wrong number of strArgs let ((_, mainArgs), _) = mget (fidToFun book) (mget (namToFid book) "main") when (length strArgs /= length mainArgs) $ do putStrLn $ "Error: 'main' expects " ++ show (length mainArgs) ++ " arguments, found " ++ show (length strArgs) exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime -- Convert string arguments to Core terms and inject them at runtime let args = map (\str -> foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str) strArgs root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") args) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

bce9fd2a7b4f23f411e570fa0716065da470021d

Add CLI string arguments

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS import Data.Either (isRight) #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr '"' '`' -> parseStr '`' #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: Char -> ParserM Core parseStr delim = do skip char delim str <- many (noneOf [delim]) char delim return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.List (partition, isPrefixOf) import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : rest) -> do let (flags, strArgs) = partition ("-" `isPrefixOf`) rest let compiled = "-c" `elem` flags let collapse = "-C" `elem` flags let search = "-S" `elem` flags let stats = "-s" `elem` flags let debug = "-d" `elem` flags let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats strArgs ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [flags] [string args...] # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> [String] -> IO (Either String ()) cliRun filePath debug compiled mode showStats strArgs = do -- Initialize the HVM hvmInit code <- readFile filePath -- Wrap the main function with any cli arguments let codeA = code ++ "\n@__main = @main(" ++ unwords (map (\s -> "\"" ++ s ++ "\"") strArgs) ++ ")" book <- doParseBook codeA -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Abort when wrong number of strArgs let ((_, mainArgs), _) = mget (fidToFun book) (mget (namToFid book) "main") when (length strArgs /= length mainArgs) $ do putStrLn $ "Error: 'main' expects " ++ show (length mainArgs) ++ " arguments, found " ++ show (length strArgs) exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "__main" (mget (namToFid book) "__main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "__main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

886bf328d8a2299b070d35fa29cf0aa156545f34

Cache .so files in .build dir

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Recompile if the cabal file has changed cabal <- readFile "HVM3.cabal" let md5 = "// md5 HVM3.cabal: " ++ show (hash (C8.pack cabal)) ++ "\n" -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [md5] ++ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cFile = ".build/" ++ fName ++ ".c" let oFile = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cFile) oldLib <- tryIOError (dlopen oFile [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> return lib -- Otherwise, recompile (_, lib) -> do either (\_ -> return ()) dlclose lib writeFile cFile mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cFile ++ " -o " ++ oFile dlopen oFile [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS import Data.Either (isRight) #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cPath = ".build/" ++ fName ++ ".c" let oPath = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cPath) oldLib <- tryIOError (dlopen oPath [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> do return lib -- Otherwise, recompile (old, lib) -> do either (\_ -> return ()) dlclose lib writeFile cPath mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cPath ++ " -o " ++ oPath dlopen oPath [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

59ade1e7924caf874415d8447a4b61a116daf4cf

Cache the compiled C files in .build

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Recompile if the cabal file has changed cabal <- readFile "HVM3.cabal" let md5 = "// md5 HVM3.cabal: " ++ show (hash (C8.pack cabal)) ++ "\n" -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [md5] ++ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cFile = ".build/" ++ fName ++ ".c" let oFile = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cFile) oldLib <- tryIOError (dlopen oFile [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> return lib -- Otherwise, recompile (_, lib) -> do either (\_ -> return ()) dlclose lib writeFile cFile mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cFile ++ " -o " ++ oFile dlopen oFile [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

6daedfbf6a7450f9902d1586009e6eb744839fa3

Revert "Cache the compiled C files in .build" This reverts commit 8830a4951f23337147a609199525893d8981aab5.

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Recompile if the cabal file has changed cabal <- readFile "HVM3.cabal" let md5 = "// md5 HVM3.cabal: " ++ show (hash (C8.pack cabal)) ++ "\n" -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [md5] ++ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cFile = ".build/" ++ fName ++ ".c" let oFile = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cFile) oldLib <- tryIOError (dlopen oFile [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> return lib -- Otherwise, recompile (_, lib) -> do either (\_ -> return ()) dlclose lib writeFile cFile mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cFile ++ " -o " ++ oFile dlopen oFile [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

8830a4951f23337147a609199525893d8981aab5

Cache the compiled C files in .build

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Crypto.Hash.MD5 (hash) import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.IO.Error (tryIOError) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.ByteString.Char8 as C8 import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit code <- readFile filePath book <- doParseBook code -- Recompile if the cabal file has changed cabal <- readFile "HVM3.cabal" let md5 = "// md5 HVM3.cabal: " ++ show (hash (C8.pack cabal)) ++ "\n" -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [md5] ++ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Try to use a cached .so file callCommand "mkdir -p .build" let fName = last $ words $ map (\c -> if c == '/' then ' ' else c) filePath let cFile = ".build/" ++ fName ++ ".c" let oFile = ".build/" ++ fName ++ ".so" oldFile <- tryIOError (readFile cFile) oldLib <- tryIOError (dlopen oFile [RTLD_NOW]) bookLib <- case (oldFile, oldLib) of -- Use the cache if the hash of the .c file matches (Right old, Right lib) | hash (C8.pack old) == hash (C8.pack mainC) -> return lib -- Otherwise, recompile (_, lib) -> do either (\_ -> return ()) dlclose lib writeFile cFile mainC callCommand $ "gcc -O2 -fPIC -shared " ++ cFile ++ " -o " ++ oFile dlopen oFile [RTLD_NOW] -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

b1c05502393bddf2b9b189345b96403a81ca40e6

show some context on this error

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: \n\x1b[2m" ++ name ++ "\n\x1b[0mIn term:\n\x1b[2m" ++ Data.List.take 256 (coreToString core) ++ "...\x1b[0m") (args state) (vars state) got host

605e06ad66b2ceeb07fbce65f82e218651a529f4

improve parse errors / import logic

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #126: type ParserM = Parsec String ParserState #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #159: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #160: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #161: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #162: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #163: -- Helper Parsers -- -------------- #164: consume :: String -> ParserM String consume str = skip >> string str #165: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #166: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #167: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #168: -- Adjusting -- --------- #169: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #170: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #171: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #172: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #173: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #174: go :: Core -> MS.Map String String -> State Int Core #175: go term ctx = case term of #176: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #177: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #178: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #179: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #180: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #181: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #182: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #183: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #184: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #185: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #186: U32 n -> return $ U32 n #187: Chr c -> return $ Chr c #188: Era -> return Era #189: -- Errors -- ------ #190: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #191: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #192: -- Debug -- ----- #193: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #194: -- //./Type.hs// #195: module HVML.Reduce where #196: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #197: reduceAt :: Bool -> ReduceAt #198: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #199: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #200: case tagT tag of #201: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #202: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #203: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #207: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #208: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #209: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #210: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #211: REF -> do reduceRefAt book host reduceAt debug book host #212: otherwise -> do return term #213: where cont host action = do ret <- action set host ret reduceAt debug book host #214: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #215: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #216: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #217: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #218: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #219: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #220: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #221: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #222: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #223: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #224: -- //./Type.hs// -- //./Inject.hs// #225: module HVML.Compile where #226: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #227: -- Compilation -- ----------- #228: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #229: type Compile = State CompileState #230: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #231: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #232: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #233: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #234: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #235: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #236: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #237: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #238: -- Full Compiler -- ------------- #239: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #240: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #241: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #242: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #243: compileFullCore book fid (Var name) host = do compileFullVar name host #244: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #245: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #246: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #247: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #248: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #249: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #250: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #251: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #252: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #253: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #254: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #255: -- Fast Compiler -- ------------- #256: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #257: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #258: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #259: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #260: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #261: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: compileFastUndo book fid term ctx itr reuse #263: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #264: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #265: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #266: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #267: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #268: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #269: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #270: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #271: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #272: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #273: compileFastCore book fid (Var name) reuse = do compileFastVar name #274: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #275: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #276: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #277: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #278: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #279: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #280: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #281: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #282: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #283: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #284: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #285: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #286: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #287: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #288: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #289: -- Type.hs: -- //./Type.hs// #290: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #291: module Main where #292: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #293: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #294: -- Main -- ---- #295: data RunMode = Normalize | Collapse | Search deriving Eq #296: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #297: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #298: -- CLI Commands -- ------------ #299: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #300: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #301: module HVML.Type where #302: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #303: -- Core Types -- ---------- #304: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #305: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #306: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #307: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #308: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #309: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #310: -- Runtime Types -- ------------- #311: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #312: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #313: --show-- type HVM = IO #314: --show-- type ReduceAt = Book -> Loc -> HVM Term #315: -- C Functions -- ----------- #316: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #317: -- Constants -- --------- #318: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #319: _DP0_ :: Tag _DP0_ = 0x00 #320: _DP1_ :: Tag _DP1_ = 0x01 #321: _VAR_ :: Tag _VAR_ = 0x02 #322: _SUB_ :: Tag _SUB_ = 0x03 #323: _REF_ :: Tag _REF_ = 0x04 #324: _LET_ :: Tag _LET_ = 0x05 #325: _APP_ :: Tag _APP_ = 0x06 #326: _MAT_ :: Tag _MAT_ = 0x08 #327: _IFL_ :: Tag _IFL_ = 0x09 #328: _SWI_ :: Tag _SWI_ = 0x0A #329: _OPX_ :: Tag _OPX_ = 0x0B #330: _OPY_ :: Tag _OPY_ = 0x0C #331: _ERA_ :: Tag _ERA_ = 0x0D #332: _LAM_ :: Tag _LAM_ = 0x0E #333: _SUP_ :: Tag _SUP_ = 0x0F #334: _CTR_ :: Tag _CTR_ = 0x10 #335: _W32_ :: Tag _W32_ = 0x11 #336: _CHR_ :: Tag _CHR_ = 0x12 #337: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #338: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #339: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #340: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #341: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #342: -- Utils -- ----- #343: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #344: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #345: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #346: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #347: //./Type.hs// #348: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #349: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #350: // Runtime Types // ------------- #351: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #352: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #353: // Constants // --------- #354: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #355: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #356: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #357: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #358: #define VOID 0x00000000000000 #359: // Heap // ---- #360: Loc get_len() { return *HVM.size; } #361: u64 get_itr() { return *HVM.itrs; } #362: u64 fresh() { return (*HVM.frsh)++; } #363: void set_len(Loc value) { *HVM.size = value; } #364: void set_itr(Loc value) { *HVM.itrs = value; } #365: // Terms // ------ #366: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #367: Tag term_tag(Term x) { return x & 0x7F; } #368: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #369: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #370: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #371: Term term_set_bit(Term term) { return term | (1ULL << 7); } #372: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #373: } #374: // u12v2 // ----- #375: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #376: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #377: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #378: // Atomics // ------- #379: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #380: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #381: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #382: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #383: Term take(Loc loc) { return swap(loc, VOID); } #384: // Allocation // ---------- #385: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #386: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #387: // Stringification // --------------- #388: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #389: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #390: void print_term_ln(Term term) { print_term(term); printf("\n"); } #391: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #392: // Evaluation // ---------- #393: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #394: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #395: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #396: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #397: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #398: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #399: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #400: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #401: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #404: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #406: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #408: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #409: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #410: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #411: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #412: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #413: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #414: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #415: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #416: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #417: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #418: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #419: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #420: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #421: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #422: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #423: while (1) { #424: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #425: switch (tag) { #426: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #427: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #429: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #431: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #432: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #433: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #434: case REF: { next = reduce_ref(next); // TODO continue; } #435: default: { #436: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #437: case LET: { next = reduce_let(prev, next); continue; } #438: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #439: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #440: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #441: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #442: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #443: default: break; } break; } } } #444: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #445: } printf("retr: ERR\n"); return 0; } #446: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #447: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #448: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #449: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #450: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #451: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #452: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #453: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #454: default: return wnf; #455: } } #456: // Primitives // ---------- #457: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #458: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #459: } #460: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #461: // Runtime Memory // -------------- #462: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #463: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #464: State* hvm_get_state() { return &HVM; } #465: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #466: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #467: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #468: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #469: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #470: -- //./Type.hs// -- //./Inject.hs// #471: module HVML.Extract where #472: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #473: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #474: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #475: ERA -> do return Era #476: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #477: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #478: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #479: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #480: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #481: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #482: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #483: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #484: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #485: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #486: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #488: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #489: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #490: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #491: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #492: _ -> do return Era #493: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #494: -- Lifting Dups -- ------------ #495: liftDups :: Core -> (Core, Core -> Core) #496: liftDups (Var nam) = (Var nam, id) #497: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #498: liftDups Era = (Era, id) #499: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #500: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #501: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #502: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #503: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #504: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #505: liftDups (U32 val) = (U32 val, id) #506: liftDups (Chr val) = (Chr val, id) #507: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #508: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #509: liftDupsList :: [Core] -> ([Core], Core -> Core) #510: liftDupsList [] = ([], id) #511: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #512: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #513: liftDupsMov [] = ([], id) #514: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #515: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #516: liftDupsCss [] = ([], id) #517: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #518: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #519: -- //./Type.hs// #520: module HVML.Inject where #521: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #522: type InjectM a = StateT InjectState HVM a #523: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #524: emptyState :: InjectState emptyState = InjectState MS.empty [] #525: injectCore :: Book -> Core -> Loc -> InjectM () #526: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #527: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #528: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #529: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #530: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #531: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #532: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #533: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #534: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #535: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #536: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #537: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #538: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #539: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , imported :: MS.Map String () , freshLabel :: Word64 } #126: type ParserM = ParsecT String ParserState IO #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- many $ choice [parseTopImp, parseTopADT, parseTopDef] try $ skip >> eof return $ concat defs #159: parseBookWithState :: ParserM ([(String, ((Bool, [(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook state <- getState return (defs, state) #160: parseTopADT :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopADT = do parseADT return [] #161: parseTopDef :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopDef = do def <- parseDef return [def] #162: -- FIXME: this is ugly code, improve it parseTopImp :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseTopImp = do try $ do skip string "import" skipMany1 space path <- many1 (noneOf "\n\r") skip st <- getState if MS.member path (imported st) then return [] else do contents <- liftIO $ readFile path modifyState (\s -> s { imported = MS.insert path () (imported s) }) st <- getState result <- liftIO $ runParserT parseBookWithState st path contents case result of Left err -> do fail $ show err Right (importedDefs, importedState) -> do putState importedState return importedDefs #163: doParseBook :: String -> IO Book doParseBook code = do result <- runParserT p (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where p = do defs <- parseBook st <- getState return (defs, st) #164: doParseCore :: String -> IO Core doParseCore code = do result <- runParserT parseCore (ParserState MS.empty MS.empty MS.empty MS.empty MS.empty 0) "" code case result of Right core -> return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #165: -- Helper Parsers -- -------------- #166: consume :: String -> ParserM String consume str = skip >> string str #167: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #168: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #169: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #170: -- Adjusting -- --------- #171: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #172: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #173: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #174: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #175: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #176: go :: Core -> MS.Map String String -> State Int Core #177: go term ctx = case term of #178: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #179: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #180: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #181: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #182: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #183: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #184: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #185: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #186: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #187: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #188: U32 n -> return $ U32 n #189: Chr c -> return $ Chr c #190: Era -> return Era #191: -- Errors -- ------ #192: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #193: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #194: -- Debug -- ----- #195: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #196: -- //./Type.hs// #197: module HVML.Reduce where #198: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #199: reduceAt :: Bool -> ReduceAt #200: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #201: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #202: case tagT tag of #203: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #204: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #205: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #207: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #208: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #209: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #210: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #211: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #212: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #213: REF -> do reduceRefAt book host reduceAt debug book host #214: otherwise -> do return term #215: where cont host action = do ret <- action set host ret reduceAt debug book host #216: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #217: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #218: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #219: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #220: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #221: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #222: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #223: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #224: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #225: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #226: -- //./Type.hs// -- //./Inject.hs// #227: module HVML.Compile where #228: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #229: -- Compilation -- ----------- #230: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #231: type Compile = State CompileState #232: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #233: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #234: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #235: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #236: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #237: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #238: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #239: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #240: -- Full Compiler -- ------------- #241: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #242: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #243: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #244: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #245: compileFullCore book fid (Var name) host = do compileFullVar name host #246: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #247: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #248: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #249: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #250: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #251: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #252: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #253: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #254: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #255: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #256: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #257: -- Fast Compiler -- ------------- #258: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #259: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #260: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #261: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #263: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #264: compileFastUndo book fid term ctx itr reuse #265: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #266: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #267: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #268: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #269: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #270: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #271: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #272: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #273: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #274: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #275: compileFastCore book fid (Var name) reuse = do compileFastVar name #276: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #277: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #278: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #279: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #280: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #281: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #282: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #283: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #284: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #285: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #286: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #287: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #288: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #289: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #290: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #291: -- Type.hs: -- //./Type.hs// #292: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #293: module Main where #294: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #295: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #296: -- Main -- ---- #297: data RunMode = Normalize | Collapse | Search deriving Eq #298: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #299: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #300: -- CLI Commands -- ------------ #301: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #302: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #303: module HVML.Type where #304: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #305: -- Core Types -- ---------- #306: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #307: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #308: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #309: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #310: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #311: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #312: -- Runtime Types -- ------------- #313: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #314: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #315: --show-- type HVM = IO #316: --show-- type ReduceAt = Book -> Loc -> HVM Term #317: -- C Functions -- ----------- #318: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #319: -- Constants -- --------- #320: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #321: _DP0_ :: Tag _DP0_ = 0x00 #322: _DP1_ :: Tag _DP1_ = 0x01 #323: _VAR_ :: Tag _VAR_ = 0x02 #324: _SUB_ :: Tag _SUB_ = 0x03 #325: _REF_ :: Tag _REF_ = 0x04 #326: _LET_ :: Tag _LET_ = 0x05 #327: _APP_ :: Tag _APP_ = 0x06 #328: _MAT_ :: Tag _MAT_ = 0x08 #329: _IFL_ :: Tag _IFL_ = 0x09 #330: _SWI_ :: Tag _SWI_ = 0x0A #331: _OPX_ :: Tag _OPX_ = 0x0B #332: _OPY_ :: Tag _OPY_ = 0x0C #333: _ERA_ :: Tag _ERA_ = 0x0D #334: _LAM_ :: Tag _LAM_ = 0x0E #335: _SUP_ :: Tag _SUP_ = 0x0F #336: _CTR_ :: Tag _CTR_ = 0x10 #337: _W32_ :: Tag _W32_ = 0x11 #338: _CHR_ :: Tag _CHR_ = 0x12 #339: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #340: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #341: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #342: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #343: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #344: -- Utils -- ----- #345: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #346: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #347: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #348: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #349: //./Type.hs// #350: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #351: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #352: // Runtime Types // ------------- #353: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #354: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #355: // Constants // --------- #356: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #357: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #358: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #359: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #360: #define VOID 0x00000000000000 #361: // Heap // ---- #362: Loc get_len() { return *HVM.size; } #363: u64 get_itr() { return *HVM.itrs; } #364: u64 fresh() { return (*HVM.frsh)++; } #365: void set_len(Loc value) { *HVM.size = value; } #366: void set_itr(Loc value) { *HVM.itrs = value; } #367: // Terms // ------ #368: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #369: Tag term_tag(Term x) { return x & 0x7F; } #370: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #371: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #372: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #373: Term term_set_bit(Term term) { return term | (1ULL << 7); } #374: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #375: } #376: // u12v2 // ----- #377: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #378: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #379: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #380: // Atomics // ------- #381: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #382: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #383: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #384: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #385: Term take(Loc loc) { return swap(loc, VOID); } #386: // Allocation // ---------- #387: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #388: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #389: // Stringification // --------------- #390: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #391: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #392: void print_term_ln(Term term) { print_term(term); printf("\n"); } #393: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #394: // Evaluation // ---------- #395: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #396: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #397: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #398: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #399: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #400: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #401: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #402: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #403: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #406: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #408: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #409: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #410: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #411: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #412: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #413: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #414: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #415: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #416: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #417: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #418: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #419: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #420: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #421: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #422: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #423: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #424: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #425: while (1) { #426: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #427: switch (tag) { #428: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #429: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #431: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #432: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #433: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #434: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #435: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #436: case REF: { next = reduce_ref(next); // TODO continue; } #437: default: { #438: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #439: case LET: { next = reduce_let(prev, next); continue; } #440: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #441: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #442: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #443: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #444: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #445: default: break; } break; } } } #446: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #447: } printf("retr: ERR\n"); return 0; } #448: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #449: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #450: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #451: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #452: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #453: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #454: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #455: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #456: default: return wnf; #457: } } #458: // Primitives // ---------- #459: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #460: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #461: } #462: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #463: // Runtime Memory // -------------- #464: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #465: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #466: State* hvm_get_state() { return &HVM; } #467: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #468: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #469: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #470: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #471: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #472: -- //./Type.hs// -- //./Inject.hs// #473: module HVML.Extract where #474: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #475: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #476: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #477: ERA -> do return Era #478: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #479: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #480: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #481: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #482: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #483: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #484: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #485: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #486: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #488: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #489: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #490: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #491: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #492: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #493: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #494: _ -> do return Era #495: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #496: -- Lifting Dups -- ------------ #497: liftDups :: Core -> (Core, Core -> Core) #498: liftDups (Var nam) = (Var nam, id) #499: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #500: liftDups Era = (Era, id) #501: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #502: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #503: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #504: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #505: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #506: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #507: liftDups (U32 val) = (U32 val, id) #508: liftDups (Chr val) = (Chr val, id) #509: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #510: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #511: liftDupsList :: [Core] -> ([Core], Core -> Core) #512: liftDupsList [] = ([], id) #513: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #514: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #515: liftDupsMov [] = ([], id) #516: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #517: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #518: liftDupsCss [] = ([], id) #519: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #520: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #521: -- //./Type.hs// #522: module HVML.Inject where #523: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #524: type InjectM a = StateT InjectState HVM a #525: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #526: emptyState :: InjectState emptyState = InjectState MS.empty [] #527: injectCore :: Book -> Core -> Loc -> InjectM () #528: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #529: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #530: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #531: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #532: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #533: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #534: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #535: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #536: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #537: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #538: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #539: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #540: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #541: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

14da2c02e08a37e48eb18235fcc3326e76f30527

show error when wrong case count

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #126: type ParserM = Parsec String ParserState #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #159: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #160: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #161: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #162: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #163: -- Helper Parsers -- -------------- #164: consume :: String -> ParserM String consume str = skip >> string str #165: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #166: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #167: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #168: -- Adjusting -- --------- #169: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #170: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #171: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #172: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #173: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #174: go :: Core -> MS.Map String String -> State Int Core #175: go term ctx = case term of #176: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #177: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #178: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #179: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #180: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #181: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #182: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #183: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #184: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #185: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #186: U32 n -> return $ U32 n #187: Chr c -> return $ Chr c #188: Era -> return Era #189: -- Errors -- ------ #190: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #191: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #192: -- Debug -- ----- #193: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #194: -- //./Type.hs// #195: module HVML.Reduce where #196: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #197: reduceAt :: Bool -> ReduceAt #198: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #199: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #200: case tagT tag of #201: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #202: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #203: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #207: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #208: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #209: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #210: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #211: REF -> do reduceRefAt book host reduceAt debug book host #212: otherwise -> do return term #213: where cont host action = do ret <- action set host ret reduceAt debug book host #214: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #215: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #216: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #217: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #218: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #219: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #220: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #221: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #222: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #223: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #224: -- //./Type.hs// -- //./Inject.hs// #225: module HVML.Compile where #226: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #227: -- Compilation -- ----------- #228: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #229: type Compile = State CompileState #230: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #231: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #232: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #233: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #234: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #235: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #236: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #237: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #238: -- Full Compiler -- ------------- #239: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #240: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #241: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #242: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #243: compileFullCore book fid (Var name) host = do compileFullVar name host #244: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #245: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #246: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #247: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #248: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #249: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #250: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #251: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #252: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #253: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #254: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #255: -- Fast Compiler -- ------------- #256: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #257: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #258: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #259: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #260: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #261: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: compileFastUndo book fid term ctx itr reuse #263: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #264: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #265: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #266: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #267: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #268: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #269: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #270: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #271: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #272: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #273: compileFastCore book fid (Var name) reuse = do compileFastVar name #274: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #275: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #276: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #277: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #278: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #279: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #280: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #281: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #282: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #283: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #284: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #285: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #286: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #287: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #288: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #289: -- Type.hs: -- //./Type.hs// #290: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #291: module Main where #292: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #293: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #294: -- Main -- ---- #295: data RunMode = Normalize | Collapse | Search deriving Eq #296: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #297: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #298: -- CLI Commands -- ------------ #299: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #300: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #301: module HVML.Type where #302: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #303: -- Core Types -- ---------- #304: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #305: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #306: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #307: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #308: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #309: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #310: -- Runtime Types -- ------------- #311: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #312: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #313: --show-- type HVM = IO #314: --show-- type ReduceAt = Book -> Loc -> HVM Term #315: -- C Functions -- ----------- #316: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #317: -- Constants -- --------- #318: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #319: _DP0_ :: Tag _DP0_ = 0x00 #320: _DP1_ :: Tag _DP1_ = 0x01 #321: _VAR_ :: Tag _VAR_ = 0x02 #322: _SUB_ :: Tag _SUB_ = 0x03 #323: _REF_ :: Tag _REF_ = 0x04 #324: _LET_ :: Tag _LET_ = 0x05 #325: _APP_ :: Tag _APP_ = 0x06 #326: _MAT_ :: Tag _MAT_ = 0x08 #327: _IFL_ :: Tag _IFL_ = 0x09 #328: _SWI_ :: Tag _SWI_ = 0x0A #329: _OPX_ :: Tag _OPX_ = 0x0B #330: _OPY_ :: Tag _OPY_ = 0x0C #331: _ERA_ :: Tag _ERA_ = 0x0D #332: _LAM_ :: Tag _LAM_ = 0x0E #333: _SUP_ :: Tag _SUP_ = 0x0F #334: _CTR_ :: Tag _CTR_ = 0x10 #335: _W32_ :: Tag _W32_ = 0x11 #336: _CHR_ :: Tag _CHR_ = 0x12 #337: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #338: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #339: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #340: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #341: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #342: -- Utils -- ----- #343: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #344: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #345: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #346: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #347: //./Type.hs// #348: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #349: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #350: // Runtime Types // ------------- #351: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #352: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #353: // Constants // --------- #354: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #355: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #356: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #357: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #358: #define VOID 0x00000000000000 #359: // Heap // ---- #360: Loc get_len() { return *HVM.size; } #361: u64 get_itr() { return *HVM.itrs; } #362: u64 fresh() { return (*HVM.frsh)++; } #363: void set_len(Loc value) { *HVM.size = value; } #364: void set_itr(Loc value) { *HVM.itrs = value; } #365: // Terms // ------ #366: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #367: Tag term_tag(Term x) { return x & 0x7F; } #368: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #369: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #370: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #371: Term term_set_bit(Term term) { return term | (1ULL << 7); } #372: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #373: } #374: // u12v2 // ----- #375: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #376: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #377: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #378: // Atomics // ------- #379: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #380: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #381: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #382: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #383: Term take(Loc loc) { return swap(loc, VOID); } #384: // Allocation // ---------- #385: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #386: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #387: // Stringification // --------------- #388: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #389: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #390: void print_term_ln(Term term) { print_term(term); printf("\n"); } #391: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #392: // Evaluation // ---------- #393: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #394: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #395: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #396: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #397: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #398: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #399: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #400: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #401: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #404: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #406: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #408: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #409: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #410: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #411: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #412: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #413: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #414: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #415: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #416: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #417: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #418: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #419: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #420: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #421: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #422: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #423: while (1) { #424: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #425: switch (tag) { #426: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #427: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #429: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #431: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #432: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #433: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #434: case REF: { next = reduce_ref(next); // TODO continue; } #435: default: { #436: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #437: case LET: { next = reduce_let(prev, next); continue; } #438: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #439: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #440: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #441: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #442: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #443: default: break; } break; } } } #444: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #445: } printf("retr: ERR\n"); return 0; } #446: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #447: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #448: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #449: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #450: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #451: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #452: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #453: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #454: default: return wnf; #455: } } #456: // Primitives // ---------- #457: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #458: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #459: } #460: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #461: // Runtime Memory // -------------- #462: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #463: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #464: State* hvm_get_state() { return &HVM; } #465: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #466: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #467: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #468: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #469: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #470: -- //./Type.hs// -- //./Inject.hs// #471: module HVML.Extract where #472: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #473: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #474: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #475: ERA -> do return Era #476: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #477: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #478: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #479: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #480: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #481: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #482: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #483: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #484: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #485: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #486: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #488: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #489: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #490: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #491: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #492: _ -> do return Era #493: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #494: -- Lifting Dups -- ------------ #495: liftDups :: Core -> (Core, Core -> Core) #496: liftDups (Var nam) = (Var nam, id) #497: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #498: liftDups Era = (Era, id) #499: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #500: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #501: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #502: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #503: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #504: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #505: liftDups (U32 val) = (U32 val, id) #506: liftDups (Chr val) = (Chr val, id) #507: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #508: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #509: liftDupsList :: [Core] -> ([Core], Core -> Core) #510: liftDupsList [] = ([], id) #511: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #512: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #513: liftDupsMov [] = ([], id) #514: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #515: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #516: liftDupsCss [] = ([], id) #517: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #518: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #519: -- //./Type.hs// #520: module HVML.Inject where #521: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #522: type InjectM a = StateT InjectState HVM a #523: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #524: emptyState :: InjectState emptyState = InjectState MS.empty [] #525: injectCore :: Book -> Core -> Loc -> InjectM () #526: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #527: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #528: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #529: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #530: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #531: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #532: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #533: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #534: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #535: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #536: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #537: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #538: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #539: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #126: type ParserM = Parsec String ParserState #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do st <- getState let adt = mget (pCtrToCid st) (let (ctr,_,_) = head css in ctr) let len = mget (pCidToLen st) adt if fromIntegral (length css) /= len then fail $ "Incorrect number of cases" else return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ do return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #159: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #160: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #161: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #162: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #163: -- Helper Parsers -- -------------- #164: consume :: String -> ParserM String consume str = skip >> string str #165: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #166: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #167: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #168: -- Adjusting -- --------- #169: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #170: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #171: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #172: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #173: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #174: go :: Core -> MS.Map String String -> State Int Core #175: go term ctx = case term of #176: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #177: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #178: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #179: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #180: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #181: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #182: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #183: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #184: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #185: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #186: U32 n -> return $ U32 n #187: Chr c -> return $ Chr c #188: Era -> return Era #189: -- Errors -- ------ #190: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #191: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #192: -- Debug -- ----- #193: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #194: -- //./Type.hs// #195: module HVML.Reduce where #196: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #197: reduceAt :: Bool -> ReduceAt #198: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #199: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #200: case tagT tag of #201: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #202: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #203: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #207: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #208: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #209: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #210: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #211: REF -> do reduceRefAt book host reduceAt debug book host #212: otherwise -> do return term #213: where cont host action = do ret <- action set host ret reduceAt debug book host #214: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #215: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #216: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #217: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #218: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #219: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #220: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #221: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #222: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #223: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #224: -- //./Type.hs// -- //./Inject.hs// #225: module HVML.Compile where #226: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #227: -- Compilation -- ----------- #228: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #229: type Compile = State CompileState #230: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #231: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #232: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #233: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #234: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #235: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #236: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #237: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #238: -- Full Compiler -- ------------- #239: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #240: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #241: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #242: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #243: compileFullCore book fid (Var name) host = do compileFullVar name host #244: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #245: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #246: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #247: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #248: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #249: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #250: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #251: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #252: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #253: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #254: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #255: -- Fast Compiler -- ------------- #256: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #257: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #258: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #259: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #260: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #261: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: compileFastUndo book fid term ctx itr reuse #263: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #264: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #265: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #266: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #267: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #268: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #269: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #270: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #271: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #272: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #273: compileFastCore book fid (Var name) reuse = do compileFastVar name #274: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #275: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #276: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #277: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #278: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #279: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #280: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #281: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #282: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #283: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #284: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #285: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #286: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #287: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #288: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #289: -- Type.hs: -- //./Type.hs// #290: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #291: module Main where #292: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #293: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #294: -- Main -- ---- #295: data RunMode = Normalize | Collapse | Search deriving Eq #296: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #297: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #298: -- CLI Commands -- ------------ #299: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #300: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #301: module HVML.Type where #302: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #303: -- Core Types -- ---------- #304: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #305: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #306: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #307: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #308: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #309: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #310: -- Runtime Types -- ------------- #311: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #312: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #313: --show-- type HVM = IO #314: --show-- type ReduceAt = Book -> Loc -> HVM Term #315: -- C Functions -- ----------- #316: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #317: -- Constants -- --------- #318: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #319: _DP0_ :: Tag _DP0_ = 0x00 #320: _DP1_ :: Tag _DP1_ = 0x01 #321: _VAR_ :: Tag _VAR_ = 0x02 #322: _SUB_ :: Tag _SUB_ = 0x03 #323: _REF_ :: Tag _REF_ = 0x04 #324: _LET_ :: Tag _LET_ = 0x05 #325: _APP_ :: Tag _APP_ = 0x06 #326: _MAT_ :: Tag _MAT_ = 0x08 #327: _IFL_ :: Tag _IFL_ = 0x09 #328: _SWI_ :: Tag _SWI_ = 0x0A #329: _OPX_ :: Tag _OPX_ = 0x0B #330: _OPY_ :: Tag _OPY_ = 0x0C #331: _ERA_ :: Tag _ERA_ = 0x0D #332: _LAM_ :: Tag _LAM_ = 0x0E #333: _SUP_ :: Tag _SUP_ = 0x0F #334: _CTR_ :: Tag _CTR_ = 0x10 #335: _W32_ :: Tag _W32_ = 0x11 #336: _CHR_ :: Tag _CHR_ = 0x12 #337: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #338: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #339: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #340: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #341: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #342: -- Utils -- ----- #343: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #344: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #345: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #346: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #347: //./Type.hs// #348: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #349: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #350: // Runtime Types // ------------- #351: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #352: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #353: // Constants // --------- #354: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #355: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #356: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #357: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #358: #define VOID 0x00000000000000 #359: // Heap // ---- #360: Loc get_len() { return *HVM.size; } #361: u64 get_itr() { return *HVM.itrs; } #362: u64 fresh() { return (*HVM.frsh)++; } #363: void set_len(Loc value) { *HVM.size = value; } #364: void set_itr(Loc value) { *HVM.itrs = value; } #365: // Terms // ------ #366: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #367: Tag term_tag(Term x) { return x & 0x7F; } #368: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #369: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #370: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #371: Term term_set_bit(Term term) { return term | (1ULL << 7); } #372: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #373: } #374: // u12v2 // ----- #375: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #376: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #377: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #378: // Atomics // ------- #379: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #380: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #381: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #382: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #383: Term take(Loc loc) { return swap(loc, VOID); } #384: // Allocation // ---------- #385: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #386: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #387: // Stringification // --------------- #388: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #389: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #390: void print_term_ln(Term term) { print_term(term); printf("\n"); } #391: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #392: // Evaluation // ---------- #393: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #394: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #395: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #396: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #397: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #398: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #399: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #400: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #401: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #404: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #406: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #408: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #409: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #410: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #411: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #412: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #413: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #414: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #415: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #416: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #417: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #418: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #419: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #420: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #421: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #422: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #423: while (1) { #424: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #425: switch (tag) { #426: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #427: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #429: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #431: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #432: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #433: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #434: case REF: { next = reduce_ref(next); // TODO continue; } #435: default: { #436: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #437: case LET: { next = reduce_let(prev, next); continue; } #438: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #439: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #440: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #441: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #442: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #443: default: break; } break; } } } #444: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #445: } printf("retr: ERR\n"); return 0; } #446: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #447: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #448: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #449: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #450: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #451: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #452: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #453: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #454: default: return wnf; #455: } } #456: // Primitives // ---------- #457: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #458: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #459: } #460: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #461: // Runtime Memory // -------------- #462: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #463: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #464: State* hvm_get_state() { return &HVM; } #465: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #466: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #467: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #468: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #469: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #470: -- //./Type.hs// -- //./Inject.hs// #471: module HVML.Extract where #472: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #473: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #474: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #475: ERA -> do return Era #476: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #477: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #478: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #479: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #480: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #481: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #482: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #483: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #484: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #485: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #486: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #488: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #489: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #490: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #491: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #492: _ -> do return Era #493: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #494: -- Lifting Dups -- ------------ #495: liftDups :: Core -> (Core, Core -> Core) #496: liftDups (Var nam) = (Var nam, id) #497: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #498: liftDups Era = (Era, id) #499: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #500: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #501: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #502: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #503: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #504: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #505: liftDups (U32 val) = (U32 val, id) #506: liftDups (Chr val) = (Chr val, id) #507: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #508: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #509: liftDupsList :: [Core] -> ([Core], Core -> Core) #510: liftDupsList [] = ([], id) #511: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #512: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #513: liftDupsMov [] = ([], id) #514: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #515: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #516: liftDupsCss [] = ([], id) #517: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #518: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #519: -- //./Type.hs// #520: module HVML.Inject where #521: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #522: type InjectM a = StateT InjectState HVM a #523: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #524: emptyState :: InjectState emptyState = InjectState MS.empty [] #525: injectCore :: Book -> Core -> Loc -> InjectM () #526: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #527: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #528: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #529: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #530: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #531: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #532: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #533: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #534: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #535: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #536: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #537: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #538: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #539: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

61473470c8b033889b1dee08fb3643f4e1a2051c

fix out of order C definitions

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #126: type ParserM = Parsec String ParserState #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #159: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #160: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #161: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #162: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #163: -- Helper Parsers -- -------------- #164: consume :: String -> ParserM String consume str = skip >> string str #165: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #166: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #167: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #168: -- Adjusting -- --------- #169: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #170: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #171: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #172: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #173: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #174: go :: Core -> MS.Map String String -> State Int Core #175: go term ctx = case term of #176: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #177: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #178: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #179: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #180: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #181: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #182: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #183: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #184: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #185: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #186: U32 n -> return $ U32 n #187: Chr c -> return $ Chr c #188: Era -> return Era #189: -- Errors -- ------ #190: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #191: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #192: -- Debug -- ----- #193: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #194: -- //./Type.hs// #195: module HVML.Reduce where #196: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #197: reduceAt :: Bool -> ReduceAt #198: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #199: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #200: case tagT tag of #201: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #202: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #203: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #207: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #208: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #209: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #210: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #211: REF -> do reduceRefAt book host reduceAt debug book host #212: otherwise -> do return term #213: where cont host action = do ret <- action set host ret reduceAt debug book host #214: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #215: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #216: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #217: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #218: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #219: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #220: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #221: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #222: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #223: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #224: -- //./Type.hs// -- //./Inject.hs// #225: module HVML.Compile where #226: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #227: -- Compilation -- ----------- #228: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #229: type Compile = State CompileState #230: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #231: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #232: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #233: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #234: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #235: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #236: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #237: -- Full Compiler -- ------------- #238: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #239: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #240: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #241: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #242: compileFullCore book fid (Var name) host = do compileFullVar name host #243: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #244: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #245: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #246: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #247: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #248: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #249: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #250: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #251: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #252: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #253: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #254: -- Fast Compiler -- ------------- #255: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #256: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #257: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #258: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #259: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #260: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #261: compileFastUndo book fid term ctx itr reuse #262: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #263: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #264: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #265: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #266: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #267: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #268: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #269: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #270: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #271: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #272: compileFastCore book fid (Var name) reuse = do compileFastVar name #273: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #274: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #275: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #276: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #277: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #278: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #279: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #280: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #281: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #282: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #283: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #284: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #285: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #286: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #287: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #288: -- Type.hs: -- //./Type.hs// #289: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #290: module Main where #291: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #292: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #293: -- Main -- ---- #294: data RunMode = Normalize | Collapse | Search deriving Eq #295: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #296: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #297: -- CLI Commands -- ------------ #298: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #299: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #300: module HVML.Type where #301: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #302: -- Core Types -- ---------- #303: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #304: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #305: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #306: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #307: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #308: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #309: -- Runtime Types -- ------------- #310: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #311: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #312: --show-- type HVM = IO #313: --show-- type ReduceAt = Book -> Loc -> HVM Term #314: -- C Functions -- ----------- #315: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #316: -- Constants -- --------- #317: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #318: _DP0_ :: Tag _DP0_ = 0x00 #319: _DP1_ :: Tag _DP1_ = 0x01 #320: _VAR_ :: Tag _VAR_ = 0x02 #321: _SUB_ :: Tag _SUB_ = 0x03 #322: _REF_ :: Tag _REF_ = 0x04 #323: _LET_ :: Tag _LET_ = 0x05 #324: _APP_ :: Tag _APP_ = 0x06 #325: _MAT_ :: Tag _MAT_ = 0x08 #326: _IFL_ :: Tag _IFL_ = 0x09 #327: _SWI_ :: Tag _SWI_ = 0x0A #328: _OPX_ :: Tag _OPX_ = 0x0B #329: _OPY_ :: Tag _OPY_ = 0x0C #330: _ERA_ :: Tag _ERA_ = 0x0D #331: _LAM_ :: Tag _LAM_ = 0x0E #332: _SUP_ :: Tag _SUP_ = 0x0F #333: _CTR_ :: Tag _CTR_ = 0x10 #334: _W32_ :: Tag _W32_ = 0x11 #335: _CHR_ :: Tag _CHR_ = 0x12 #336: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #337: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #338: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #339: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #340: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #341: -- Utils -- ----- #342: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #343: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #344: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #345: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #346: //./Type.hs// #347: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #348: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #349: // Runtime Types // ------------- #350: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #351: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #352: // Constants // --------- #353: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #354: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #355: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #356: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #357: #define VOID 0x00000000000000 #358: // Heap // ---- #359: Loc get_len() { return *HVM.size; } #360: u64 get_itr() { return *HVM.itrs; } #361: u64 fresh() { return (*HVM.frsh)++; } #362: void set_len(Loc value) { *HVM.size = value; } #363: void set_itr(Loc value) { *HVM.itrs = value; } #364: // Terms // ------ #365: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #366: Tag term_tag(Term x) { return x & 0x7F; } #367: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #368: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #369: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #370: Term term_set_bit(Term term) { return term | (1ULL << 7); } #371: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #372: } #373: // u12v2 // ----- #374: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #375: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #376: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #377: // Atomics // ------- #378: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #379: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #380: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #381: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #382: Term take(Loc loc) { return swap(loc, VOID); } #383: // Allocation // ---------- #384: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #385: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #386: // Stringification // --------------- #387: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #388: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #389: void print_term_ln(Term term) { print_term(term); printf("\n"); } #390: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #391: // Evaluation // ---------- #392: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #393: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #394: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #395: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #396: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #397: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #398: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #399: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #400: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #403: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #406: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #407: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #408: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #409: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #410: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #411: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #412: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #413: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #414: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #415: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #416: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #417: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #418: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #419: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #420: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #421: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #422: while (1) { #423: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #424: switch (tag) { #425: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #426: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #427: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #429: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #430: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #431: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #432: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #433: case REF: { next = reduce_ref(next); // TODO continue; } #434: default: { #435: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #436: case LET: { next = reduce_let(prev, next); continue; } #437: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #438: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #439: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #440: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #441: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #442: default: break; } break; } } } #443: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #444: } printf("retr: ERR\n"); return 0; } #445: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #446: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #447: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #448: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #449: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #450: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #451: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #452: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #453: default: return wnf; #454: } } #455: // Primitives // ---------- #456: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #457: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #458: } #459: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #460: // Runtime Memory // -------------- #461: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #462: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #463: State* hvm_get_state() { return &HVM; } #464: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #465: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #466: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #467: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #468: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #469: -- //./Type.hs// -- //./Inject.hs// #470: module HVML.Extract where #471: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #472: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #473: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #474: ERA -> do return Era #475: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #476: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #477: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #478: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #479: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #480: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #481: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #482: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #483: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #484: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #485: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #486: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #487: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #488: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #489: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #490: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #491: _ -> do return Era #492: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #493: -- Lifting Dups -- ------------ #494: liftDups :: Core -> (Core, Core -> Core) #495: liftDups (Var nam) = (Var nam, id) #496: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #497: liftDups Era = (Era, id) #498: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #499: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #500: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #501: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #502: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #503: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #504: liftDups (U32 val) = (U32 val, id) #505: liftDups (Chr val) = (Chr val, id) #506: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #507: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #508: liftDupsList :: [Core] -> ([Core], Core -> Core) #509: liftDupsList [] = ([], id) #510: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #511: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #512: liftDupsMov [] = ([], id) #513: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #514: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #515: liftDupsCss [] = ([], id) #516: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #517: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #518: -- //./Type.hs// #519: module HVML.Inject where #520: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #521: type InjectM a = StateT InjectState HVM a #522: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #523: emptyState :: InjectState emptyState = InjectState MS.empty [] #524: injectCore :: Book -> Core -> Loc -> InjectM () #525: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #526: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #527: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #528: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #529: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #530: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #531: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #532: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #533: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #534: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #535: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #536: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #537: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #538: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyNil core <|> prettyStr core <|> prettyLst core #112: prettyNil :: Core -> Maybe String prettyNil (Ctr "#Nil" []) = Just "[]" prettyNil _ = Nothing #113: prettyStr :: Core -> Maybe String prettyStr (Ctr "#Nil" []) = Just "\"\"" prettyStr (Ctr "#Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #114: prettyLst :: Core -> Maybe String prettyLst (Ctr "#Nil" []) = Just "[]" prettyLst (Ctr "#Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #115: -- Dumping -- ------- #116: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #117: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #118: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #119: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #120: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #121: -- //./Type.hs// #122: module HVML.Parse where #123: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #124: -- Core Parsers -- ------------ #125: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #126: type ParserM = Parsec String ParserState #127: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #128: '*' -> do consume "*" return Era #129: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #130: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #131: '@' -> do parseRef #132: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #133: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #134: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #135: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #136: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #137: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #138: '#' -> parseCtr #139: '~' -> parseMat #140: '[' -> parseLst #141: '\'' -> parseChr #142: '"' -> parseStr #143: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #144: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #145: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr ('#':nam) fds #146: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return ('#':ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do st <- getState cid <- case ctr of ('#':_) -> case MS.lookup ctr (pCtrToCid st) of Nothing -> fail $ "Constructor not defined: " ++ ctr Just cid -> return $ cid -- Constructor Case: sort by CID _ -> case reads ctr of [(num :: Word64, "")] -> return $ num -- Numeric Case: sort by value _ -> return $ maxBound -- Default Case: always last return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Switch if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css -- Match with only 1 case: a default case (forbidden) else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." -- Match with a default case: turn into If-Let chain else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets -- Match with all cases covered else do return $ Mat val mov css #147: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #148: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #149: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #150: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #151: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "#Cons" [Chr c, acc]) (Ctr "#Nil" []) str #152: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "#Cons" [x, acc]) (Ctr "#Nil" []) elems #153: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #155: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #156: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\ (ctr,cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\ (_,cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #157: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member ('#':name) (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return ('#':name, fields) #158: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #159: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #160: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #161: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #162: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #163: -- Helper Parsers -- -------------- #164: consume :: String -> ParserM String consume str = skip >> string str #165: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #166: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #167: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #168: -- Adjusting -- --------- #169: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #170: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #171: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #172: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #173: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #174: go :: Core -> MS.Map String String -> State Int Core #175: go term ctx = case term of #176: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #177: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #178: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #179: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #180: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #181: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #182: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #183: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #184: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #185: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #186: U32 n -> return $ U32 n #187: Chr c -> return $ Chr c #188: Era -> return Era #189: -- Errors -- ------ #190: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #191: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #192: -- Debug -- ----- #193: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #194: -- //./Type.hs// #195: module HVML.Reduce where #196: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #197: reduceAt :: Bool -> ReduceAt #198: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #199: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #200: case tagT tag of #201: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #202: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #203: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #206: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #207: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #208: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #209: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #210: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #211: REF -> do reduceRefAt book host reduceAt debug book host #212: otherwise -> do return term #213: where cont host action = do ret <- action set host ret reduceAt debug book host #214: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #215: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #216: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #217: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #218: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #219: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #220: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #221: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #222: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #223: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #224: -- //./Type.hs// -- //./Inject.hs// #225: module HVML.Compile where #226: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #227: -- Compilation -- ----------- #228: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #229: type Compile = State CompileState #230: compileHeaders :: Book -> String compileHeaders book = let funcs = MS.toList (fidToNam book) decls_f = map (\(_, name) -> "Term " ++ name ++ "_f(Term);") funcs decls_t = map (\(_, name) -> "Term " ++ name ++ "_t(Term);") funcs in unlines $ decls_f ++ decls_t #231: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #232: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #233: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #234: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #235: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #236: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #237: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #238: -- Full Compiler -- ------------- #239: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #240: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #241: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #242: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #243: compileFullCore book fid (Var name) host = do compileFullVar name host #244: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #245: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #246: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #247: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #248: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #249: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #250: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #251: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #252: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #253: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #254: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #255: -- Fast Compiler -- ------------- #256: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #257: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #258: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #259: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #260: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #261: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #262: compileFastUndo book fid term ctx itr reuse #263: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #264: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #265: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #266: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #267: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #268: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #269: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #270: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #271: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #272: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #273: compileFastCore book fid (Var name) reuse = do compileFastVar name #274: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #275: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #276: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #277: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #278: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #279: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #280: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #281: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #282: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #283: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #284: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #285: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #286: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #287: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #288: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #289: -- Type.hs: -- //./Type.hs// #290: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #291: module Main where #292: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #293: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #294: -- Main -- ---- #295: data RunMode = Normalize | Collapse | Search deriving Eq #296: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #297: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #298: -- CLI Commands -- ------------ #299: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let decls = compileHeaders book let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ [decls] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #300: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #301: module HVML.Type where #302: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #303: -- Core Types -- ---------- #304: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #305: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #306: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #307: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #308: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #309: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #310: -- Runtime Types -- ------------- #311: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #312: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #313: --show-- type HVM = IO #314: --show-- type ReduceAt = Book -> Loc -> HVM Term #315: -- C Functions -- ----------- #316: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #317: -- Constants -- --------- #318: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #319: _DP0_ :: Tag _DP0_ = 0x00 #320: _DP1_ :: Tag _DP1_ = 0x01 #321: _VAR_ :: Tag _VAR_ = 0x02 #322: _SUB_ :: Tag _SUB_ = 0x03 #323: _REF_ :: Tag _REF_ = 0x04 #324: _LET_ :: Tag _LET_ = 0x05 #325: _APP_ :: Tag _APP_ = 0x06 #326: _MAT_ :: Tag _MAT_ = 0x08 #327: _IFL_ :: Tag _IFL_ = 0x09 #328: _SWI_ :: Tag _SWI_ = 0x0A #329: _OPX_ :: Tag _OPX_ = 0x0B #330: _OPY_ :: Tag _OPY_ = 0x0C #331: _ERA_ :: Tag _ERA_ = 0x0D #332: _LAM_ :: Tag _LAM_ = 0x0E #333: _SUP_ :: Tag _SUP_ = 0x0F #334: _CTR_ :: Tag _CTR_ = 0x10 #335: _W32_ :: Tag _W32_ = 0x11 #336: _CHR_ :: Tag _CHR_ = 0x12 #337: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #338: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #339: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #340: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #341: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #342: -- Utils -- ----- #343: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #344: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #345: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #346: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #347: //./Type.hs// #348: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #349: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #350: // Runtime Types // ------------- #351: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #352: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #353: // Constants // --------- #354: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #355: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #356: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #357: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #358: #define VOID 0x00000000000000 #359: // Heap // ---- #360: Loc get_len() { return *HVM.size; } #361: u64 get_itr() { return *HVM.itrs; } #362: u64 fresh() { return (*HVM.frsh)++; } #363: void set_len(Loc value) { *HVM.size = value; } #364: void set_itr(Loc value) { *HVM.itrs = value; } #365: // Terms // ------ #366: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #367: Tag term_tag(Term x) { return x & 0x7F; } #368: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #369: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #370: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #371: Term term_set_bit(Term term) { return term | (1ULL << 7); } #372: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #373: } #374: // u12v2 // ----- #375: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #376: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #377: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #378: // Atomics // ------- #379: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #380: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #381: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #382: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #383: Term take(Loc loc) { return swap(loc, VOID); } #384: // Allocation // ---------- #385: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #386: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #387: // Stringification // --------------- #388: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #389: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #390: void print_term_ln(Term term) { print_term(term); printf("\n"); } #391: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #392: // Evaluation // ---------- #393: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #394: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #395: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #396: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #397: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #398: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #399: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #400: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #401: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #404: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #406: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #407: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #408: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #409: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #410: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #411: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #412: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #413: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #414: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #415: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #416: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #417: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #418: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #419: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #420: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #421: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #422: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #423: while (1) { #424: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #425: switch (tag) { #426: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #427: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #429: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #430: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #431: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #432: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #433: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #434: case REF: { next = reduce_ref(next); // TODO continue; } #435: default: { #436: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #437: case LET: { next = reduce_let(prev, next); continue; } #438: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #439: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #440: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #441: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #442: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #443: default: break; } break; } } } #444: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #445: } printf("retr: ERR\n"); return 0; } #446: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #447: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #448: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #449: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #450: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #451: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #452: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #453: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #454: default: return wnf; #455: } } #456: // Primitives // ---------- #457: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #458: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #459: } #460: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #461: // Runtime Memory // -------------- #462: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #463: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #464: State* hvm_get_state() { return &HVM; } #465: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #466: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #467: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #468: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #469: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #470: -- //./Type.hs// -- //./Inject.hs// #471: module HVML.Extract where #472: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #473: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #474: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #475: ERA -> do return Era #476: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #477: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #478: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #479: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #480: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #481: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #482: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #483: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #484: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #485: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #486: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #487: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #488: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #489: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #490: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #491: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #492: _ -> do return Era #493: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #494: -- Lifting Dups -- ------------ #495: liftDups :: Core -> (Core, Core -> Core) #496: liftDups (Var nam) = (Var nam, id) #497: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #498: liftDups Era = (Era, id) #499: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #500: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #501: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #502: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #503: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #504: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #505: liftDups (U32 val) = (U32 val, id) #506: liftDups (Chr val) = (Chr val, id) #507: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #508: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #509: liftDupsList :: [Core] -> ([Core], Core -> Core) #510: liftDupsList [] = ([], id) #511: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #512: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #513: liftDupsMov [] = ([], id) #514: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #515: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #516: liftDupsCss [] = ([], id) #517: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #518: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #519: -- //./Type.hs// #520: module HVML.Inject where #521: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #522: type InjectM a = StateT InjectState HVM a #523: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #524: emptyState :: InjectState emptyState = InjectState MS.empty [] #525: injectCore :: Book -> Core -> Loc -> InjectM () #526: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #527: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #528: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #529: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #530: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #531: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #532: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #533: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #534: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #535: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #536: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #537: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #538: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #539: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

67b4dc8795d0d7e231addebc400d181bec9a3d3e

fix import order issue

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code MS.empty case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: resolve :: String -> MS.Map String () -> IO String resolve code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ (acc, imp) imp' -> do let file = drop 7 imp' if MS.member file imp then return (acc, imp) else do content <- readFile file resolved <- resolve content (MS.insert file () imp) return (resolved : acc, MS.insert file () imp)) ([], imported) imports return $ unlines (filter (not . null) (reverse (fst resolvedImports)) ++ rest) #161: -- Helper Parsers -- -------------- #162: consume :: String -> ParserM String consume str = skip >> string str #163: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #164: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #165: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #166: -- Adjusting -- --------- #167: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #168: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #169: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #170: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #171: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #172: go :: Core -> MS.Map String String -> State Int Core #173: go term ctx = case term of #174: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #175: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #176: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #177: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #178: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #179: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #180: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #181: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #182: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #183: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #184: U32 n -> return $ U32 n #185: Chr c -> return $ Chr c #186: Era -> return Era #187: -- Errors -- ------ #188: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #189: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #190: -- Debug -- ----- #191: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #192: -- //./Type.hs// #193: module HVML.Reduce where #194: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #195: reduceAt :: Bool -> ReduceAt #196: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #197: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #198: case tagT tag of #199: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #200: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #201: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #202: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #203: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #205: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #206: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #207: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #208: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #209: REF -> do reduceRefAt book host reduceAt debug book host #210: otherwise -> do return term #211: where cont host action = do ret <- action set host ret reduceAt debug book host #212: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #213: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #214: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #215: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #216: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #217: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #218: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #219: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #220: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #221: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #222: -- //./Type.hs// -- //./Inject.hs// #223: module HVML.Compile where #224: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #225: -- Compilation -- ----------- #226: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #227: type Compile = State CompileState #228: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #229: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #230: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #231: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #232: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #233: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #234: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #235: -- Full Compiler -- ------------- #236: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #237: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #238: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #239: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #240: compileFullCore book fid (Var name) host = do compileFullVar name host #241: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #242: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #243: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #244: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #245: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #246: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #247: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #248: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #249: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #250: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #251: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #252: -- Fast Compiler -- ------------- #253: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #254: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #255: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #256: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #257: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #258: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #259: compileFastUndo book fid term ctx itr reuse #260: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #261: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #262: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #263: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #264: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #265: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #266: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #267: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #268: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #269: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #270: compileFastCore book fid (Var name) reuse = do compileFastVar name #271: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #272: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #273: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #274: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #275: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #276: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #277: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #278: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #279: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #280: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #281: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #282: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #283: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #284: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #285: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #286: -- Type.hs: -- //./Type.hs// #287: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #288: module Main where #289: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #290: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #291: -- Main -- ---- #292: data RunMode = Normalize | Collapse | Search deriving Eq #293: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #294: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #295: -- CLI Commands -- ------------ #296: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #297: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #298: module HVML.Type where #299: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #300: -- Core Types -- ---------- #301: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #302: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #303: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #304: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #305: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #306: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #307: -- Runtime Types -- ------------- #308: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #309: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #310: --show-- type HVM = IO #311: --show-- type ReduceAt = Book -> Loc -> HVM Term #312: -- C Functions -- ----------- #313: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #314: -- Constants -- --------- #315: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #316: _DP0_ :: Tag _DP0_ = 0x00 #317: _DP1_ :: Tag _DP1_ = 0x01 #318: _VAR_ :: Tag _VAR_ = 0x02 #319: _SUB_ :: Tag _SUB_ = 0x03 #320: _REF_ :: Tag _REF_ = 0x04 #321: _LET_ :: Tag _LET_ = 0x05 #322: _APP_ :: Tag _APP_ = 0x06 #323: _MAT_ :: Tag _MAT_ = 0x08 #324: _IFL_ :: Tag _IFL_ = 0x09 #325: _SWI_ :: Tag _SWI_ = 0x0A #326: _OPX_ :: Tag _OPX_ = 0x0B #327: _OPY_ :: Tag _OPY_ = 0x0C #328: _ERA_ :: Tag _ERA_ = 0x0D #329: _LAM_ :: Tag _LAM_ = 0x0E #330: _SUP_ :: Tag _SUP_ = 0x0F #331: _CTR_ :: Tag _CTR_ = 0x10 #332: _W32_ :: Tag _W32_ = 0x11 #333: _CHR_ :: Tag _CHR_ = 0x12 #334: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #335: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #336: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #337: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #338: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #339: -- Utils -- ----- #340: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #341: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #342: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #343: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #344: //./Type.hs// #345: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #346: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #347: // Runtime Types // ------------- #348: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #349: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #350: // Constants // --------- #351: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #352: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #353: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #354: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #355: #define VOID 0x00000000000000 #356: // Heap // ---- #357: Loc get_len() { return *HVM.size; } #358: u64 get_itr() { return *HVM.itrs; } #359: u64 fresh() { return (*HVM.frsh)++; } #360: void set_len(Loc value) { *HVM.size = value; } #361: void set_itr(Loc value) { *HVM.itrs = value; } #362: // Terms // ------ #363: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #364: Tag term_tag(Term x) { return x & 0x7F; } #365: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #366: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #367: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #368: Term term_set_bit(Term term) { return term | (1ULL << 7); } #369: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #370: } #371: // u12v2 // ----- #372: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #373: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #374: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #375: // Atomics // ------- #376: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #377: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #378: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #379: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #380: Term take(Loc loc) { return swap(loc, VOID); } #381: // Allocation // ---------- #382: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #383: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #384: // Stringification // --------------- #385: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #386: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #387: void print_term_ln(Term term) { print_term(term); printf("\n"); } #388: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #389: // Evaluation // ---------- #390: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #391: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #392: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #393: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #394: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #395: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #396: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #397: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #398: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #401: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #405: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #406: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #407: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #408: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #409: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #410: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #411: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #412: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #413: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #414: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #415: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #416: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #417: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #418: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #419: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #420: while (1) { #421: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #422: switch (tag) { #423: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #424: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #425: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #426: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #427: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #428: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #429: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #430: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #431: case REF: { next = reduce_ref(next); // TODO continue; } #432: default: { #433: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #434: case LET: { next = reduce_let(prev, next); continue; } #435: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #436: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #437: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #438: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #439: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #440: default: break; } break; } } } #441: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #442: } printf("retr: ERR\n"); return 0; } #443: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #444: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #445: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #446: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #447: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #448: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #449: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #450: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #451: default: return wnf; #452: } } #453: // Primitives // ---------- #454: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #455: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #456: } #457: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #458: // Runtime Memory // -------------- #459: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #460: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #461: State* hvm_get_state() { return &HVM; } #462: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #463: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #464: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #465: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #466: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #467: -- //./Type.hs// -- //./Inject.hs// #468: module HVML.Extract where #469: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #470: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #471: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #472: ERA -> do return Era #473: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #474: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #475: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #476: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #477: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #478: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #479: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #480: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #481: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #482: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #483: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #484: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #485: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #486: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #487: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #488: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #489: _ -> do return Era #490: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #491: -- Lifting Dups -- ------------ #492: liftDups :: Core -> (Core, Core -> Core) #493: liftDups (Var nam) = (Var nam, id) #494: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #495: liftDups Era = (Era, id) #496: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #497: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #498: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #499: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #500: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #501: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #502: liftDups (U32 val) = (U32 val, id) #503: liftDups (Chr val) = (Chr val, id) #504: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #505: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #506: liftDupsList :: [Core] -> ([Core], Core -> Core) #507: liftDupsList [] = ([], id) #508: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #509: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #510: liftDupsMov [] = ([], id) #511: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #512: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #513: liftDupsCss [] = ([], id) #514: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #515: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #516: -- //./Type.hs// #517: module HVML.Inject where #518: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #519: type InjectM a = StateT InjectState HVM a #520: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #521: emptyState :: InjectState emptyState = InjectState MS.empty [] #522: injectCore :: Book -> Core -> Loc -> InjectM () #523: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #524: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #525: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #526: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #527: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #528: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #529: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #530: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #531: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #532: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #533: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #534: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #535: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #536: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.IORef import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip defs <- manyTill (choice [parseADTBlock, parseDefBlock]) fileEnd return $ catMaybes defs where fileEnd = try $ skip >> eof parseADTBlock = do { parseADT; return Nothing } parseDefBlock = do { def <- parseDef; return $ Just def } #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: resolve :: String -> IO String resolve code = do imported <- newIORef MS.empty resolveGo code imported #161: resolveGo :: String -> IORef (MS.Map String ()) -> IO String resolveGo code imported = do let state = ParserState MS.empty MS.empty MS.empty MS.empty 0 let code' = case runParser (skip >> getInput) state "" code of Right rem -> rem Left _ -> code let ls = lines code' let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- foldM (\ acc imp' -> do let file = drop 7 imp' imp <- readIORef imported if MS.member file imp then return acc else do content <- readFile file modifyIORef imported (MS.insert file ()) resolved <- resolveGo content imported return (resolved : acc)) [] imports return $ unlines (filter (not . null) (reverse resolvedImports) ++ rest) #162: -- Helper Parsers -- -------------- #163: consume :: String -> ParserM String consume str = skip >> string str #164: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #165: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #166: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #167: -- Adjusting -- --------- #168: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #169: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #170: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #171: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #172: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #173: go :: Core -> MS.Map String String -> State Int Core #174: go term ctx = case term of #175: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #176: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #177: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #178: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #179: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #180: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #181: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #182: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #183: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #184: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #185: U32 n -> return $ U32 n #186: Chr c -> return $ Chr c #187: Era -> return Era #188: -- Errors -- ------ #189: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #190: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False #191: -- Debug -- ----- #192: parseLog :: String -> ParserM () parseLog msg = do pos <- getPosition remaining <- getInput let preview = "[[[" ++ Data.List.take 20 remaining ++ (if length remaining > 20 then "..." else "") ++ "]]]" trace ("[" ++ show pos ++ "] " ++ msg ++ "\nRemaining code: " ++ preview) $ return () ./Reduce.hs #193: -- //./Type.hs// #194: module HVML.Reduce where #195: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #196: reduceAt :: Bool -> ReduceAt #197: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #198: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #199: case tagT tag of #200: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #201: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #202: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #203: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #204: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #205: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #206: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #207: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #208: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #209: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #210: REF -> do reduceRefAt book host reduceAt debug book host #211: otherwise -> do return term #212: where cont host action = do ret <- action set host ret reduceAt debug book host #213: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #214: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #215: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #216: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #217: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #218: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #219: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #220: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #221: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #222: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #223: -- //./Type.hs// -- //./Inject.hs// #224: module HVML.Compile where #225: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #226: -- Compilation -- ----------- #227: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #228: type Compile = State CompileState #229: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #230: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #231: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #232: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #233: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #234: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #235: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #236: -- Full Compiler -- ------------- #237: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #238: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #239: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #240: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #241: compileFullCore book fid (Var name) host = do compileFullVar name host #242: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #243: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #244: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #245: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #246: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #247: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #248: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #249: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #250: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #251: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #252: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #253: -- Fast Compiler -- ------------- #254: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #255: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #256: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #257: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #258: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #259: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #260: compileFastUndo book fid term ctx itr reuse #261: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #262: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #263: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #264: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #265: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #266: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #267: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #268: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #269: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #270: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #271: compileFastCore book fid (Var name) reuse = do compileFastVar name #272: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #273: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #274: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #275: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #276: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #277: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #278: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #279: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #280: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #281: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #282: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #283: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #284: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #285: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #286: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #287: -- Type.hs: -- //./Type.hs// #288: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #289: module Main where #290: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import Data.IORef import qualified Data.Map.Strict as MS #291: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #292: -- Main -- ---- #293: data RunMode = Normalize | Collapse | Search deriving Eq #294: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #295: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #296: -- CLI Commands -- ------------ #297: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do lastItrs <- newIORef 0 forM_ vals $ \ term -> do currItrs <- getItr prevItrs <- readIORef lastItrs -- printf "%012d %012d %s\n" currItrs (currItrs - prevItrs) (showCore term) printf "%s\n" (showCore term) writeIORef lastItrs currItrs -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #298: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #299: module HVML.Type where #300: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #301: -- Core Types -- ---------- #302: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #303: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #304: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #305: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #306: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #307: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #308: -- Runtime Types -- ------------- #309: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #310: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #311: --show-- type HVM = IO #312: --show-- type ReduceAt = Book -> Loc -> HVM Term #313: -- C Functions -- ----------- #314: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #315: -- Constants -- --------- #316: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #317: _DP0_ :: Tag _DP0_ = 0x00 #318: _DP1_ :: Tag _DP1_ = 0x01 #319: _VAR_ :: Tag _VAR_ = 0x02 #320: _SUB_ :: Tag _SUB_ = 0x03 #321: _REF_ :: Tag _REF_ = 0x04 #322: _LET_ :: Tag _LET_ = 0x05 #323: _APP_ :: Tag _APP_ = 0x06 #324: _MAT_ :: Tag _MAT_ = 0x08 #325: _IFL_ :: Tag _IFL_ = 0x09 #326: _SWI_ :: Tag _SWI_ = 0x0A #327: _OPX_ :: Tag _OPX_ = 0x0B #328: _OPY_ :: Tag _OPY_ = 0x0C #329: _ERA_ :: Tag _ERA_ = 0x0D #330: _LAM_ :: Tag _LAM_ = 0x0E #331: _SUP_ :: Tag _SUP_ = 0x0F #332: _CTR_ :: Tag _CTR_ = 0x10 #333: _W32_ :: Tag _W32_ = 0x11 #334: _CHR_ :: Tag _CHR_ = 0x12 #335: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #336: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #337: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #338: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #339: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #340: -- Utils -- ----- #341: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #342: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #343: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #344: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #345: //./Type.hs// #346: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #347: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #348: // Runtime Types // ------------- #349: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #350: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #351: // Constants // --------- #352: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #353: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #354: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #355: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #356: #define VOID 0x00000000000000 #357: // Heap // ---- #358: Loc get_len() { return *HVM.size; } #359: u64 get_itr() { return *HVM.itrs; } #360: u64 fresh() { return (*HVM.frsh)++; } #361: void set_len(Loc value) { *HVM.size = value; } #362: void set_itr(Loc value) { *HVM.itrs = value; } #363: // Terms // ------ #364: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #365: Tag term_tag(Term x) { return x & 0x7F; } #366: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #367: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #368: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #369: Term term_set_bit(Term term) { return term | (1ULL << 7); } #370: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #371: } #372: // u12v2 // ----- #373: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #374: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #375: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #376: // Atomics // ------- #377: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #378: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #379: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #380: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #381: Term take(Loc loc) { return swap(loc, VOID); } #382: // Allocation // ---------- #383: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #384: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #385: // Stringification // --------------- #386: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #387: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #388: void print_term_ln(Term term) { print_term(term); printf("\n"); } #389: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #390: // Evaluation // ---------- #391: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #392: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #393: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #394: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #395: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #396: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #397: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #398: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #399: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #402: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #403: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #404: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #405: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #406: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #407: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #408: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #409: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #410: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #411: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #412: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #413: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #414: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #415: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #416: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #417: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #418: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #419: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #420: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #421: while (1) { #422: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #423: switch (tag) { #424: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #425: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #426: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #427: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #428: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #429: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #430: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #431: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #432: case REF: { next = reduce_ref(next); // TODO continue; } #433: default: { #434: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #435: case LET: { next = reduce_let(prev, next); continue; } #436: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #437: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #438: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #439: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #440: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #441: default: break; } break; } } } #442: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #443: } printf("retr: ERR\n"); return 0; } #444: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #445: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #446: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #447: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #448: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #449: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #450: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #451: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #452: default: return wnf; #453: } } #454: // Primitives // ---------- #455: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #456: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #457: } #458: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #459: // Runtime Memory // -------------- #460: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #461: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #462: State* hvm_get_state() { return &HVM; } #463: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #464: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #465: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #466: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #467: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #468: -- //./Type.hs// -- //./Inject.hs// #469: module HVML.Extract where #470: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #471: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #472: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host -- trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #473: ERA -> do return Era #474: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #475: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #476: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #477: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #478: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #479: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #480: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #481: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #482: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #483: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #484: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #485: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #486: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #487: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #488: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #489: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #490: _ -> do return Era #491: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #492: -- Lifting Dups -- ------------ #493: liftDups :: Core -> (Core, Core -> Core) #494: liftDups (Var nam) = (Var nam, id) #495: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #496: liftDups Era = (Era, id) #497: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #498: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #499: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #500: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #501: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #502: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #503: liftDups (U32 val) = (U32 val, id) #504: liftDups (Chr val) = (Chr val, id) #505: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #506: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #507: liftDupsList :: [Core] -> ([Core], Core -> Core) #508: liftDupsList [] = ([], id) #509: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #510: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #511: liftDupsMov [] = ([], id) #512: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #513: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #514: liftDupsCss [] = ([], id) #515: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #516: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #517: -- //./Type.hs// #518: module HVML.Inject where #519: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #520: type InjectM a = StateT InjectState HVM a #521: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #522: emptyState :: InjectState emptyState = InjectState MS.empty [] #523: injectCore :: Book -> Core -> Loc -> InjectM () #524: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #525: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #526: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #527: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #528: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #529: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #530: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #531: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #532: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #533: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #534: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #535: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #536: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #537: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

c2c6d50d6107ba89f3ed0afc530df2d5e41d27bf

Revert "change time to ms instead of seconds" This reverts commit 42ae410ce3c5bfeccb95185147468c142c092e31.

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: resolve :: String -> IO String resolve code = do let ls = lines code let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- forM imports $ \imp -> do let file = drop 7 imp content <- readFile file resolve content return $ unlines (resolvedImports ++ rest) #161: -- Helper Parsers -- -------------- #162: consume :: String -> ParserM String consume str = skip >> string str #163: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #164: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #165: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #166: -- Adjusting -- --------- #167: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #168: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #169: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #170: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #171: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #172: go :: Core -> MS.Map String String -> State Int Core #173: go term ctx = case term of #174: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #175: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #176: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #177: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #178: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #179: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #180: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #181: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #182: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #183: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #184: U32 n -> return $ U32 n #185: Chr c -> return $ Chr c #186: Era -> return Era #187: -- Errors -- ------ #188: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #189: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #190: -- //./Type.hs// #191: module HVML.Reduce where #192: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #193: reduceAt :: Bool -> ReduceAt #194: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #195: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #196: case tagT tag of #197: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #198: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #199: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #202: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #203: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #204: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #205: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #206: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #207: REF -> do reduceRefAt book host reduceAt debug book host #208: otherwise -> do return term #209: where cont host action = do ret <- action set host ret reduceAt debug book host #210: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #211: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #212: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #213: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #214: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #215: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #216: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #217: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #218: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #219: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #220: -- //./Type.hs// -- //./Inject.hs// #221: module HVML.Compile where #222: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #223: -- Compilation -- ----------- #224: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #225: type Compile = State CompileState #226: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #227: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #228: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #229: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #230: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #231: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #232: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #233: -- Full Compiler -- ------------- #234: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #235: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #236: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #237: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #238: compileFullCore book fid (Var name) host = do compileFullVar name host #239: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #240: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #241: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #242: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #243: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #244: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #245: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #246: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #247: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #248: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #249: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #250: -- Fast Compiler -- ------------- #251: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #252: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #253: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #254: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #256: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #257: compileFastUndo book fid term ctx itr reuse #258: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #259: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #260: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #261: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #262: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #263: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #264: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #265: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #266: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #267: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #268: compileFastCore book fid (Var name) reuse = do compileFastVar name #269: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #270: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #271: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #272: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #273: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #274: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #275: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #276: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #277: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #278: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #279: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #280: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #281: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #282: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #283: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #284: -- Type.hs: -- //./Type.hs// #285: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #286: module Main where #287: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #288: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #289: -- Main -- ---- #290: data RunMode = Normalize | Collapse | Search deriving Eq #291: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #292: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #293: -- CLI Commands -- ------------ #294: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itrs / 1000000.0) / (time/1000.0) printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f ms\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #295: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs ms\\n\", time);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #296: module HVML.Type where #297: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #298: -- Core Types -- ---------- #299: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #300: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #301: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #302: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #303: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #304: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #305: -- Runtime Types -- ------------- #306: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #307: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #308: --show-- type HVM = IO #309: --show-- type ReduceAt = Book -> Loc -> HVM Term #310: -- C Functions -- ----------- #311: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #312: -- Constants -- --------- #313: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #314: _DP0_ :: Tag _DP0_ = 0x00 #315: _DP1_ :: Tag _DP1_ = 0x01 #316: _VAR_ :: Tag _VAR_ = 0x02 #317: _SUB_ :: Tag _SUB_ = 0x03 #318: _REF_ :: Tag _REF_ = 0x04 #319: _LET_ :: Tag _LET_ = 0x05 #320: _APP_ :: Tag _APP_ = 0x06 #321: _MAT_ :: Tag _MAT_ = 0x08 #322: _IFL_ :: Tag _IFL_ = 0x09 #323: _SWI_ :: Tag _SWI_ = 0x0A #324: _OPX_ :: Tag _OPX_ = 0x0B #325: _OPY_ :: Tag _OPY_ = 0x0C #326: _ERA_ :: Tag _ERA_ = 0x0D #327: _LAM_ :: Tag _LAM_ = 0x0E #328: _SUP_ :: Tag _SUP_ = 0x0F #329: _CTR_ :: Tag _CTR_ = 0x10 #330: _W32_ :: Tag _W32_ = 0x11 #331: _CHR_ :: Tag _CHR_ = 0x12 #332: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #333: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #334: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #335: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #336: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #337: -- Utils -- ----- #338: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #339: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #340: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #341: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #342: //./Type.hs// #343: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #344: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #345: // Runtime Types // ------------- #346: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #347: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #348: // Constants // --------- #349: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #350: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #351: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #352: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #353: #define VOID 0x00000000000000 #354: // Heap // ---- #355: Loc get_len() { return *HVM.size; } #356: u64 get_itr() { return *HVM.itrs; } #357: u64 fresh() { return (*HVM.frsh)++; } #358: void set_len(Loc value) { *HVM.size = value; } #359: void set_itr(Loc value) { *HVM.itrs = value; } #360: // Terms // ------ #361: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #362: Tag term_tag(Term x) { return x & 0x7F; } #363: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #364: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #365: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #366: Term term_set_bit(Term term) { return term | (1ULL << 7); } #367: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #368: } #369: // u12v2 // ----- #370: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #371: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #372: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #373: // Atomics // ------- #374: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #375: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #376: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #377: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #378: Term take(Loc loc) { return swap(loc, VOID); } #379: // Allocation // ---------- #380: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #381: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #382: // Stringification // --------------- #383: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #384: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #385: void print_term_ln(Term term) { print_term(term); printf("\n"); } #386: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #387: // Evaluation // ---------- #388: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #389: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #390: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #391: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #392: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #393: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #394: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #395: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #396: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #399: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #403: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #404: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #405: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #406: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #407: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #408: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #409: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #410: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #411: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #412: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #413: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #414: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #415: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #416: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #417: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #418: while (1) { #419: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #420: switch (tag) { #421: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #422: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #425: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #426: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #427: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #428: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #429: case REF: { next = reduce_ref(next); // TODO continue; } #430: default: { #431: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #432: case LET: { next = reduce_let(prev, next); continue; } #433: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #434: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #435: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #436: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #437: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #438: default: break; } break; } } } #439: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #440: } printf("retr: ERR\n"); return 0; } #441: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #442: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #443: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #444: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #445: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #446: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #447: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #449: default: return wnf; #450: } } #451: // Primitives // ---------- #452: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #453: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #454: } #455: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #456: // Runtime Memory // -------------- #457: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #458: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #459: State* hvm_get_state() { return &HVM; } #460: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #461: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #462: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #463: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #464: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #465: -- //./Type.hs// -- //./Inject.hs// #466: module HVML.Extract where #467: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #468: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #469: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #470: ERA -> do return Era #471: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #472: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #473: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #474: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #475: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #476: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #477: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #478: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #479: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #481: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #482: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #483: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #484: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #486: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #487: _ -> do return Era #488: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #489: -- Lifting Dups -- ------------ #490: liftDups :: Core -> (Core, Core -> Core) #491: liftDups (Var nam) = (Var nam, id) #492: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #493: liftDups Era = (Era, id) #494: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #495: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #496: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #497: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #498: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #499: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #500: liftDups (U32 val) = (U32 val, id) #501: liftDups (Chr val) = (Chr val, id) #502: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #503: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #504: liftDupsList :: [Core] -> ([Core], Core -> Core) #505: liftDupsList [] = ([], id) #506: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #507: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #508: liftDupsMov [] = ([], id) #509: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #510: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #511: liftDupsCss [] = ([], id) #512: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #513: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #514: -- //./Type.hs// #515: module HVML.Inject where #516: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #517: type InjectM a = StateT InjectState HVM a #518: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #519: emptyState :: InjectState emptyState = InjectState MS.empty [] #520: injectCore :: Book -> Core -> Loc -> InjectM () #521: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #522: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #523: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #524: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #525: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #526: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #527: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #528: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #529: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #530: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #531: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #532: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #533: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #534: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = do resolvedCode <- resolve code case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" resolvedCode of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" resolvedCode err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: resolve :: String -> IO String resolve code = do let ls = lines code let (imports, rest) = span (isPrefixOf "import ") ls resolvedImports <- forM imports $ \imp -> do let file = drop 7 imp content <- readFile file resolve content return $ unlines (resolvedImports ++ rest) #161: -- Helper Parsers -- -------------- #162: consume :: String -> ParserM String consume str = skip >> string str #163: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #164: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #165: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #166: -- Adjusting -- --------- #167: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #168: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #169: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #170: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #171: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #172: go :: Core -> MS.Map String String -> State Int Core #173: go term ctx = case term of #174: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #175: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #176: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #177: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #178: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #179: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #180: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #181: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #182: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #183: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #184: U32 n -> return $ U32 n #185: Chr c -> return $ Chr c #186: Era -> return Era #187: -- Errors -- ------ #188: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #189: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #190: -- //./Type.hs// #191: module HVML.Reduce where #192: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #193: reduceAt :: Bool -> ReduceAt #194: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #195: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #196: case tagT tag of #197: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #198: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #199: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #202: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #203: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #204: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #205: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #206: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #207: REF -> do reduceRefAt book host reduceAt debug book host #208: otherwise -> do return term #209: where cont host action = do ret <- action set host ret reduceAt debug book host #210: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #211: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #212: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #213: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #214: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #215: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #216: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #217: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #218: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #219: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #220: -- //./Type.hs// -- //./Inject.hs// #221: module HVML.Compile where #222: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #223: -- Compilation -- ----------- #224: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #225: type Compile = State CompileState #226: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #227: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #228: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #229: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #230: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #231: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #232: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #233: -- Full Compiler -- ------------- #234: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #235: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #236: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #237: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #238: compileFullCore book fid (Var name) host = do compileFullVar name host #239: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #240: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #241: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #242: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #243: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #244: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #245: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #246: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #247: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #248: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #249: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #250: -- Fast Compiler -- ------------- #251: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #252: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #253: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #254: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #256: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #257: compileFastUndo book fid term ctx itr reuse #258: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #259: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #260: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #261: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #262: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #263: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #264: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #265: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #266: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #267: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #268: compileFastCore book fid (Var name) reuse = do compileFastVar name #269: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #270: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #271: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #272: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #273: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #274: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #275: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #276: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #277: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #278: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #279: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #280: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #281: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #282: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #283: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #284: -- Type.hs: -- //./Type.hs// #285: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #286: module Main where #287: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #288: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #289: -- Main -- ---- #290: data RunMode = Normalize | Collapse | Search deriving Eq #291: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #292: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #293: -- CLI Commands -- ------------ #294: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #295: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #296: module HVML.Type where #297: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #298: -- Core Types -- ---------- #299: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #300: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #301: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #302: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #303: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #304: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #305: -- Runtime Types -- ------------- #306: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #307: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #308: --show-- type HVM = IO #309: --show-- type ReduceAt = Book -> Loc -> HVM Term #310: -- C Functions -- ----------- #311: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #312: -- Constants -- --------- #313: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #314: _DP0_ :: Tag _DP0_ = 0x00 #315: _DP1_ :: Tag _DP1_ = 0x01 #316: _VAR_ :: Tag _VAR_ = 0x02 #317: _SUB_ :: Tag _SUB_ = 0x03 #318: _REF_ :: Tag _REF_ = 0x04 #319: _LET_ :: Tag _LET_ = 0x05 #320: _APP_ :: Tag _APP_ = 0x06 #321: _MAT_ :: Tag _MAT_ = 0x08 #322: _IFL_ :: Tag _IFL_ = 0x09 #323: _SWI_ :: Tag _SWI_ = 0x0A #324: _OPX_ :: Tag _OPX_ = 0x0B #325: _OPY_ :: Tag _OPY_ = 0x0C #326: _ERA_ :: Tag _ERA_ = 0x0D #327: _LAM_ :: Tag _LAM_ = 0x0E #328: _SUP_ :: Tag _SUP_ = 0x0F #329: _CTR_ :: Tag _CTR_ = 0x10 #330: _W32_ :: Tag _W32_ = 0x11 #331: _CHR_ :: Tag _CHR_ = 0x12 #332: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #333: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #334: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #335: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #336: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #337: -- Utils -- ----- #338: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #339: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #340: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #341: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #342: //./Type.hs// #343: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #344: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #345: // Runtime Types // ------------- #346: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #347: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #348: // Constants // --------- #349: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #350: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #351: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #352: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #353: #define VOID 0x00000000000000 #354: // Heap // ---- #355: Loc get_len() { return *HVM.size; } #356: u64 get_itr() { return *HVM.itrs; } #357: u64 fresh() { return (*HVM.frsh)++; } #358: void set_len(Loc value) { *HVM.size = value; } #359: void set_itr(Loc value) { *HVM.itrs = value; } #360: // Terms // ------ #361: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #362: Tag term_tag(Term x) { return x & 0x7F; } #363: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #364: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #365: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #366: Term term_set_bit(Term term) { return term | (1ULL << 7); } #367: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #368: } #369: // u12v2 // ----- #370: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #371: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #372: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #373: // Atomics // ------- #374: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #375: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #376: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #377: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #378: Term take(Loc loc) { return swap(loc, VOID); } #379: // Allocation // ---------- #380: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #381: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #382: // Stringification // --------------- #383: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #384: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #385: void print_term_ln(Term term) { print_term(term); printf("\n"); } #386: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #387: // Evaluation // ---------- #388: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #389: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #390: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #391: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #392: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #393: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #394: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #395: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #396: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #399: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #403: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #404: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #405: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #406: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #407: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #408: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #409: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #410: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #411: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #412: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #413: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #414: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #415: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #416: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #417: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #418: while (1) { #419: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #420: switch (tag) { #421: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #422: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #425: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #426: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #427: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #428: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #429: case REF: { next = reduce_ref(next); // TODO continue; } #430: default: { #431: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #432: case LET: { next = reduce_let(prev, next); continue; } #433: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #434: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #435: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #436: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #437: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #438: default: break; } break; } } } #439: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #440: } printf("retr: ERR\n"); return 0; } #441: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #442: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #443: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #444: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #445: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #446: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #447: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #449: default: return wnf; #450: } } #451: // Primitives // ---------- #452: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #453: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #454: } #455: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #456: // Runtime Memory // -------------- #457: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #458: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #459: State* hvm_get_state() { return &HVM; } #460: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #461: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #462: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #463: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #464: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #465: -- //./Type.hs// -- //./Inject.hs// #466: module HVML.Extract where #467: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #468: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #469: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #470: ERA -> do return Era #471: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #472: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #473: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #474: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #475: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #476: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #477: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #478: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #479: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #481: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #482: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #483: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #484: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #486: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #487: _ -> do return Era #488: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #489: -- Lifting Dups -- ------------ #490: liftDups :: Core -> (Core, Core -> Core) #491: liftDups (Var nam) = (Var nam, id) #492: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #493: liftDups Era = (Era, id) #494: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #495: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #496: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #497: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #498: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #499: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #500: liftDups (U32 val) = (U32 val, id) #501: liftDups (Chr val) = (Chr val, id) #502: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #503: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #504: liftDupsList :: [Core] -> ([Core], Core -> Core) #505: liftDupsList [] = ([], id) #506: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #507: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #508: liftDupsMov [] = ([], id) #509: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #510: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #511: liftDupsCss [] = ([], id) #512: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #513: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #514: -- //./Type.hs// #515: module HVML.Inject where #516: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #517: type InjectM a = StateT InjectState HVM a #518: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #519: emptyState :: InjectState emptyState = InjectState MS.empty [] #520: injectCore :: Book -> Core -> Loc -> InjectM () #521: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #522: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #523: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #524: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #525: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #526: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #527: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #528: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #529: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #530: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #531: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #532: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #533: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #534: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

42ae410ce3c5bfeccb95185147468c142c092e31

change time to ms instead of seconds

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #218: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #219: -- //./Type.hs// -- //./Inject.hs// #220: module HVML.Compile where #221: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #222: -- Compilation -- ----------- #223: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #224: type Compile = State CompileState #225: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #226: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #227: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #228: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #229: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #230: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #231: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #232: -- Full Compiler -- ------------- #233: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #234: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #235: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #236: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #237: compileFullCore book fid (Var name) host = do compileFullVar name host #238: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #239: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #240: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #241: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #242: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #243: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #244: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #245: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #246: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #247: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #248: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #249: -- Fast Compiler -- ------------- #250: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #251: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #252: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #253: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #255: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #256: compileFastUndo book fid term ctx itr reuse #257: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #259: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #260: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #261: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #262: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #263: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #264: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #265: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #266: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #267: compileFastCore book fid (Var name) reuse = do compileFastVar name #268: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #269: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #270: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #271: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #272: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #273: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #274: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #275: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #276: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #277: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #278: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #279: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #280: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #281: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #282: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #283: -- Type.hs: -- //./Type.hs// #284: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #285: module Main where #286: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #287: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #288: -- Main -- ---- #289: data RunMode = Normalize | Collapse | Search deriving Eq #290: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #291: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #292: -- CLI Commands -- ------------ #293: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #294: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #295: module HVML.Type where #296: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #297: -- Core Types -- ---------- #298: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #299: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #300: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #301: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #302: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #303: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #304: -- Runtime Types -- ------------- #305: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #306: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #307: --show-- type HVM = IO #308: --show-- type ReduceAt = Book -> Loc -> HVM Term #309: -- C Functions -- ----------- #310: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #311: -- Constants -- --------- #312: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #313: _DP0_ :: Tag _DP0_ = 0x00 #314: _DP1_ :: Tag _DP1_ = 0x01 #315: _VAR_ :: Tag _VAR_ = 0x02 #316: _SUB_ :: Tag _SUB_ = 0x03 #317: _REF_ :: Tag _REF_ = 0x04 #318: _LET_ :: Tag _LET_ = 0x05 #319: _APP_ :: Tag _APP_ = 0x06 #320: _MAT_ :: Tag _MAT_ = 0x08 #321: _IFL_ :: Tag _IFL_ = 0x09 #322: _SWI_ :: Tag _SWI_ = 0x0A #323: _OPX_ :: Tag _OPX_ = 0x0B #324: _OPY_ :: Tag _OPY_ = 0x0C #325: _ERA_ :: Tag _ERA_ = 0x0D #326: _LAM_ :: Tag _LAM_ = 0x0E #327: _SUP_ :: Tag _SUP_ = 0x0F #328: _CTR_ :: Tag _CTR_ = 0x10 #329: _W32_ :: Tag _W32_ = 0x11 #330: _CHR_ :: Tag _CHR_ = 0x12 #331: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #332: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #333: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #334: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #340: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #341: //./Type.hs// #342: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #343: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #344: // Runtime Types // ------------- #345: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #346: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #347: // Constants // --------- #348: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #349: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #350: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #351: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #352: #define VOID 0x00000000000000 #353: // Heap // ---- #354: Loc get_len() { return *HVM.size; } #355: u64 get_itr() { return *HVM.itrs; } #356: u64 fresh() { return (*HVM.frsh)++; } #357: void set_len(Loc value) { *HVM.size = value; } #358: void set_itr(Loc value) { *HVM.itrs = value; } #359: // Terms // ------ #360: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #361: Tag term_tag(Term x) { return x & 0x7F; } #362: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #363: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #364: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #365: Term term_set_bit(Term term) { return term | (1ULL << 7); } #366: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #367: } #368: // u12v2 // ----- #369: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #370: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #371: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #372: // Atomics // ------- #373: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #374: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #375: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #376: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #377: Term take(Loc loc) { return swap(loc, VOID); } #378: // Allocation // ---------- #379: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #380: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #381: // Stringification // --------------- #382: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #383: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #384: void print_term_ln(Term term) { print_term(term); printf("\n"); } #385: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #386: // Evaluation // ---------- #387: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #388: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #389: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #390: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #391: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #392: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #393: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #394: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #395: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #398: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #402: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #403: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #404: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #405: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #406: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #407: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #408: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #409: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #410: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #411: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #412: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #413: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #414: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #415: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #416: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #417: while (1) { #418: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #419: switch (tag) { #420: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #421: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #425: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #426: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #427: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #428: case REF: { next = reduce_ref(next); // TODO continue; } #429: default: { #430: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #431: case LET: { next = reduce_let(prev, next); continue; } #432: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #433: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #434: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #435: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #436: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #437: default: break; } break; } } } #438: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #439: } printf("retr: ERR\n"); return 0; } #440: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #441: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #442: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #443: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #444: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #445: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #446: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: default: return wnf; #449: } } #450: // Primitives // ---------- #451: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #452: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #453: } #454: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #463: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #464: -- //./Type.hs// -- //./Inject.hs// #465: module HVML.Extract where #466: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #467: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #468: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #469: ERA -> do return Era #470: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #471: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #472: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #473: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #474: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #475: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #476: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #477: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #478: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #479: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #480: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #481: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #482: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #483: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #486: _ -> do return Era #487: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #488: -- Lifting Dups -- ------------ #489: liftDups :: Core -> (Core, Core -> Core) #490: liftDups (Var nam) = (Var nam, id) #491: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #492: liftDups Era = (Era, id) #493: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #494: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #495: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #496: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #497: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #498: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #499: liftDups (U32 val) = (U32 val, id) #500: liftDups (Chr val) = (Chr val, id) #501: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #502: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #503: liftDupsList :: [Core] -> ([Core], Core -> Core) #504: liftDupsList [] = ([], id) #505: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #506: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #507: liftDupsMov [] = ([], id) #508: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #509: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #510: liftDupsCss [] = ([], id) #511: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #512: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #513: -- //./Type.hs// #514: module HVML.Inject where #515: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #516: type InjectM a = StateT InjectState HVM a #517: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #518: emptyState :: InjectState emptyState = InjectState MS.empty [] #519: injectCore :: Book -> Core -> Loc -> InjectM () #520: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #521: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #522: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #523: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #524: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #525: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #526: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #527: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #528: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #529: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #530: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #531: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #532: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #533: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #218: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #219: -- //./Type.hs// -- //./Inject.hs// #220: module HVML.Compile where #221: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #222: -- Compilation -- ----------- #223: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #224: type Compile = State CompileState #225: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #226: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #227: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #228: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #229: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #230: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #231: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #232: -- Full Compiler -- ------------- #233: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #234: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #235: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #236: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #237: compileFullCore book fid (Var name) host = do compileFullVar name host #238: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #239: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #240: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #241: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #242: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #243: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #244: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } let mat = "term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") mat mov #245: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #246: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #247: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #248: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #249: -- Fast Compiler -- ------------- #250: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #251: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #252: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #253: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #255: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ") - " ++ show (matFirstCid book term) ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #256: compileFastUndo book fid term ctx itr reuse #257: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #259: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #260: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #261: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #262: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #263: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #264: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #265: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #266: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #267: compileFastCore book fid (Var name) reuse = do compileFastVar name #268: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #269: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #270: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #271: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #272: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #273: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #274: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #275: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #276: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #277: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #278: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #279: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #280: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #281: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #282: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #283: -- Type.hs: -- //./Type.hs// #284: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #285: module Main where #286: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #287: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #288: -- Main -- ---- #289: data RunMode = Normalize | Collapse | Search deriving Eq #290: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #291: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #292: -- CLI Commands -- ------------ #293: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itrs / 1000000.0) / (time/1000.0) printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f ms\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #294: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs ms\\n\", time);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #295: module HVML.Type where #296: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #297: -- Core Types -- ---------- #298: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #299: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #300: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #301: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #302: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #303: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #304: -- Runtime Types -- ------------- #305: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #306: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #307: --show-- type HVM = IO #308: --show-- type ReduceAt = Book -> Loc -> HVM Term #309: -- C Functions -- ----------- #310: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #311: -- Constants -- --------- #312: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #313: _DP0_ :: Tag _DP0_ = 0x00 #314: _DP1_ :: Tag _DP1_ = 0x01 #315: _VAR_ :: Tag _VAR_ = 0x02 #316: _SUB_ :: Tag _SUB_ = 0x03 #317: _REF_ :: Tag _REF_ = 0x04 #318: _LET_ :: Tag _LET_ = 0x05 #319: _APP_ :: Tag _APP_ = 0x06 #320: _MAT_ :: Tag _MAT_ = 0x08 #321: _IFL_ :: Tag _IFL_ = 0x09 #322: _SWI_ :: Tag _SWI_ = 0x0A #323: _OPX_ :: Tag _OPX_ = 0x0B #324: _OPY_ :: Tag _OPY_ = 0x0C #325: _ERA_ :: Tag _ERA_ = 0x0D #326: _LAM_ :: Tag _LAM_ = 0x0E #327: _SUP_ :: Tag _SUP_ = 0x0F #328: _CTR_ :: Tag _CTR_ = 0x10 #329: _W32_ :: Tag _W32_ = 0x11 #330: _CHR_ :: Tag _CHR_ = 0x12 #331: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #332: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #333: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #334: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #340: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #341: //./Type.hs// #342: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #343: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #344: // Runtime Types // ------------- #345: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #346: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #347: // Constants // --------- #348: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #349: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #350: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #351: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #352: #define VOID 0x00000000000000 #353: // Heap // ---- #354: Loc get_len() { return *HVM.size; } #355: u64 get_itr() { return *HVM.itrs; } #356: u64 fresh() { return (*HVM.frsh)++; } #357: void set_len(Loc value) { *HVM.size = value; } #358: void set_itr(Loc value) { *HVM.itrs = value; } #359: // Terms // ------ #360: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #361: Tag term_tag(Term x) { return x & 0x7F; } #362: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #363: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #364: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #365: Term term_set_bit(Term term) { return term | (1ULL << 7); } #366: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #367: } #368: // u12v2 // ----- #369: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #370: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #371: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #372: // Atomics // ------- #373: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #374: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #375: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #376: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #377: Term take(Loc loc) { return swap(loc, VOID); } #378: // Allocation // ---------- #379: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #380: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #381: // Stringification // --------------- #382: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #383: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #384: void print_term_ln(Term term) { print_term(term); printf("\n"); } #385: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #386: // Evaluation // ---------- #387: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #388: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #389: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #390: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #391: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #392: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #393: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #394: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #395: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #398: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #402: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #403: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #404: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #405: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #406: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #407: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #408: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #409: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #410: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #411: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #412: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #413: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #414: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #415: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #416: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #417: while (1) { #418: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #419: switch (tag) { #420: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #421: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #425: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #426: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #427: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #428: case REF: { next = reduce_ref(next); // TODO continue; } #429: default: { #430: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #431: case LET: { next = reduce_let(prev, next); continue; } #432: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #433: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #434: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #435: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #436: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #437: default: break; } break; } } } #438: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #439: } printf("retr: ERR\n"); return 0; } #440: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #441: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #442: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #443: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #444: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #445: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #446: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: default: return wnf; #449: } } #450: // Primitives // ---------- #451: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #452: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #453: } #454: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #463: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #464: -- //./Type.hs// -- //./Inject.hs// #465: module HVML.Extract where #466: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #467: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #468: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #469: ERA -> do return Era #470: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #471: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #472: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #473: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #474: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #475: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #476: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #477: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #478: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #479: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #480: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #481: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #482: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #483: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #486: _ -> do return Era #487: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #488: -- Lifting Dups -- ------------ #489: liftDups :: Core -> (Core, Core -> Core) #490: liftDups (Var nam) = (Var nam, id) #491: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #492: liftDups Era = (Era, id) #493: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #494: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #495: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #496: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #497: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #498: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #499: liftDups (U32 val) = (U32 val, id) #500: liftDups (Chr val) = (Chr val, id) #501: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #502: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #503: liftDupsList :: [Core] -> ([Core], Core -> Core) #504: liftDupsList [] = ([], id) #505: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #506: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #507: liftDupsMov [] = ([], id) #508: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #509: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #510: liftDupsCss [] = ([], id) #511: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #512: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #513: -- //./Type.hs// #514: module HVML.Inject where #515: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #516: type InjectM a = StateT InjectState HVM a #517: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #518: emptyState :: InjectState emptyState = InjectState MS.empty [] #519: injectCore :: Book -> Core -> Loc -> InjectM () #520: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #521: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #522: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #523: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #524: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #525: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #526: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #527: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #528: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #529: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #530: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #531: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #532: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #533: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

d524ad5f4b2e70d917c3d328ec48d480380077ec

store only FID on REF terms

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ")) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #273: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #274: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #275: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #276: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #277: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #278: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #279: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #280: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #281: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #282: -- Type.hs: -- //./Type.hs// #283: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #284: module Main where #285: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #286: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #287: -- Main -- ---- #288: data RunMode = Normalize | Collapse | Search deriving Eq #289: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #290: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #291: -- CLI Commands -- ------------ #292: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #293: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #294: module HVML.Type where #295: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #296: -- Core Types -- ---------- #297: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #298: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #299: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #300: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #301: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #302: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #303: -- Runtime Types -- ------------- #304: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #305: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #306: --show-- type HVM = IO #307: --show-- type ReduceAt = Book -> Loc -> HVM Term #308: -- C Functions -- ----------- #309: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #310: -- Constants -- --------- #311: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #312: _DP0_ :: Tag _DP0_ = 0x00 #313: _DP1_ :: Tag _DP1_ = 0x01 #314: _VAR_ :: Tag _VAR_ = 0x02 #315: _SUB_ :: Tag _SUB_ = 0x03 #316: _REF_ :: Tag _REF_ = 0x04 #317: _LET_ :: Tag _LET_ = 0x05 #318: _APP_ :: Tag _APP_ = 0x06 #319: _MAT_ :: Tag _MAT_ = 0x08 #320: _IFL_ :: Tag _IFL_ = 0x09 #321: _SWI_ :: Tag _SWI_ = 0x0A #322: _OPX_ :: Tag _OPX_ = 0x0B #323: _OPY_ :: Tag _OPY_ = 0x0C #324: _ERA_ :: Tag _ERA_ = 0x0D #325: _LAM_ :: Tag _LAM_ = 0x0E #326: _SUP_ :: Tag _SUP_ = 0x0F #327: _CTR_ :: Tag _CTR_ = 0x10 #328: _W32_ :: Tag _W32_ = 0x11 #329: _CHR_ :: Tag _CHR_ = 0x12 #330: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #331: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #332: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #333: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #334: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #340: //./Type.hs// #341: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #342: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #343: // Runtime Types // ------------- #344: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #345: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #346: // Constants // --------- #347: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #348: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #349: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #350: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #351: #define VOID 0x00000000000000 #352: // Heap // ---- #353: Loc get_len() { return *HVM.size; } #354: u64 get_itr() { return *HVM.itrs; } #355: u64 fresh() { return (*HVM.frsh)++; } #356: void set_len(Loc value) { *HVM.size = value; } #357: void set_itr(Loc value) { *HVM.itrs = value; } #358: // Terms // ------ #359: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #360: Tag term_tag(Term x) { return x & 0x7F; } #361: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #362: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #363: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #364: Term term_set_bit(Term term) { return term | (1ULL << 7); } #365: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #366: } #367: // u12v2 // ----- #368: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #369: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #370: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #371: // Atomics // ------- #372: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #373: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #374: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #375: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #376: Term take(Loc loc) { return swap(loc, VOID); } #377: // Allocation // ---------- #378: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #379: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #380: // Stringification // --------------- #381: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #382: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #383: void print_term_ln(Term term) { print_term(term); printf("\n"); } #384: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #385: // Evaluation // ---------- #386: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #387: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #388: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #389: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #390: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #391: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #392: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #393: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #394: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #395: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #397: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #401: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #402: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #403: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #404: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #405: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #406: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #407: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #408: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #409: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #410: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #411: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #412: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #413: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #414: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #415: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #416: while (1) { #417: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #418: switch (tag) { #419: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #420: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #421: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #424: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #425: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #426: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #427: case REF: { next = reduce_ref(next); // TODO continue; } #428: default: { #429: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #430: case LET: { next = reduce_let(prev, next); continue; } #431: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #432: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #433: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #434: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #435: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #436: default: break; } break; } } } #437: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #438: } printf("retr: ERR\n"); return 0; } #439: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #440: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #441: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #442: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #443: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #444: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #445: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #446: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: default: return wnf; #448: } } #449: // Primitives // ---------- #450: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #451: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #452: } #453: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #454: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #463: -- //./Type.hs// -- //./Inject.hs// #464: module HVML.Extract where #465: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #466: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #467: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #468: ERA -> do return Era #469: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #470: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #471: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #472: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #473: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #474: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #475: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #476: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #477: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #478: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #479: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #481: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #482: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #483: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #485: _ -> do return Era #486: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #487: -- Lifting Dups -- ------------ #488: liftDups :: Core -> (Core, Core -> Core) #489: liftDups (Var nam) = (Var nam, id) #490: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #491: liftDups Era = (Era, id) #492: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #493: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #494: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #495: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #496: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #497: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #498: liftDups (U32 val) = (U32 val, id) #499: liftDups (Chr val) = (Chr val, id) #500: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #501: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #502: liftDupsList :: [Core] -> ([Core], Core -> Core) #503: liftDupsList [] = ([], id) #504: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #505: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #506: liftDupsMov [] = ([], id) #507: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #508: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #509: liftDupsCss [] = ([], id) #510: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #511: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #512: -- //./Type.hs// #513: module HVML.Inject where #514: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #515: type InjectM a = StateT InjectState HVM a #516: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #517: emptyState :: InjectState emptyState = InjectState MS.empty [] #518: injectCore :: Book -> Core -> Loc -> InjectM () #519: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #520: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #521: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #522: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #523: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #524: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #525: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #526: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #527: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #528: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #529: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #530: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #531: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #532: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = lab let ari = funArity book fid case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) #218: -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject ./Compile.hs #219: -- //./Type.hs// -- //./Inject.hs// #220: module HVML.Compile where #221: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #222: -- Compilation -- ----------- #223: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #224: type Compile = State CompileState #225: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #226: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #227: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #228: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #229: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #230: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #231: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #232: -- Full Compiler -- ------------- #233: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #234: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #235: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #236: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #237: compileFullCore book fid (Var name) host = do compileFullVar name host #238: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #239: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #240: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #241: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #242: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #243: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #244: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #245: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #246: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #247: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #248: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #249: -- Fast Compiler -- ------------- #250: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #251: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #252: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #253: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #255: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ")) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #256: compileFastUndo book fid term ctx itr reuse #257: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #259: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #260: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #261: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #262: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #263: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #264: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #265: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #266: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #267: compileFastCore book fid (Var name) reuse = do compileFastVar name #268: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #269: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #270: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #271: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #272: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #273: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #274: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #275: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #276: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #277: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #278: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #279: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #280: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, " ++ show rFid ++ ", " ++ refNam ++ ")" #281: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #282: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #283: -- Type.hs: -- //./Type.hs// #284: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #285: module Main where #286: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #287: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #288: -- Main -- ---- #289: data RunMode = Normalize | Collapse | Search deriving Eq #290: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #291: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #292: -- CLI Commands -- ------------ #293: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \ (cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \ (cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \ (cid, adt) -> do hvmSetCadt cid (fromIntegral adt) forM_ (MS.toList (fidToFun book)) $ \ (fid, ((_, args), _)) -> do hvmSetFari fid (fromIntegral $ length args) -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #294: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, "++show mainFid++", 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #295: module HVML.Type where #296: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #297: -- Core Types -- ---------- #298: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #299: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #300: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #301: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #302: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #303: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #304: -- Runtime Types -- ------------- #305: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #306: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #307: --show-- type HVM = IO #308: --show-- type ReduceAt = Book -> Loc -> HVM Term #309: -- C Functions -- ----------- #310: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_fari" hvmSetFari :: Word64 -> Word16 -> IO () #311: -- Constants -- --------- #312: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #313: _DP0_ :: Tag _DP0_ = 0x00 #314: _DP1_ :: Tag _DP1_ = 0x01 #315: _VAR_ :: Tag _VAR_ = 0x02 #316: _SUB_ :: Tag _SUB_ = 0x03 #317: _REF_ :: Tag _REF_ = 0x04 #318: _LET_ :: Tag _LET_ = 0x05 #319: _APP_ :: Tag _APP_ = 0x06 #320: _MAT_ :: Tag _MAT_ = 0x08 #321: _IFL_ :: Tag _IFL_ = 0x09 #322: _SWI_ :: Tag _SWI_ = 0x0A #323: _OPX_ :: Tag _OPX_ = 0x0B #324: _OPY_ :: Tag _OPY_ = 0x0C #325: _ERA_ :: Tag _ERA_ = 0x0D #326: _LAM_ :: Tag _LAM_ = 0x0E #327: _SUP_ :: Tag _SUP_ = 0x0F #328: _CTR_ :: Tag _CTR_ = 0x10 #329: _W32_ :: Tag _W32_ = 0x11 #330: _CHR_ :: Tag _CHR_ = 0x12 #331: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #332: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #333: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #334: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" #340: funArity :: Book -> Word64 -> Word64 funArity book fid | fid == _SUP_F_ = 3 | fid == _DUP_F_ = 3 | fid == _LOG_F_ = 1 | otherwise = case MS.lookup fid (fidToFun book) of Just ((_, args), _) -> fromIntegral (length args) Nothing -> error $ "Function ID not found: " ++ show fid ./Runtime.c #341: //./Type.hs// #342: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #343: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #344: // Runtime Types // ------------- #345: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[65536])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor u16 fari[65536]; // arity of each function } State; #346: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, .fari = {0}, }; #347: // Constants // --------- #348: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #349: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #350: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #351: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #352: #define VOID 0x00000000000000 #353: // Heap // ---- #354: Loc get_len() { return *HVM.size; } #355: u64 get_itr() { return *HVM.itrs; } #356: u64 fresh() { return (*HVM.frsh)++; } #357: void set_len(Loc value) { *HVM.size = value; } #358: void set_itr(Loc value) { *HVM.itrs = value; } #359: // Terms // ------ #360: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #361: Tag term_tag(Term x) { return x & 0x7F; } #362: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #363: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #364: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #365: Term term_set_bit(Term term) { return term | (1ULL << 7); } #366: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #367: } #368: // u12v2 // ----- #369: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #370: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #371: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #372: // Atomics // ------- #373: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #374: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #375: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #376: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #377: Term take(Loc loc) { return swap(loc, VOID); } #378: // Allocation // ---------- #379: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #380: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #381: // Stringification // --------------- #382: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #383: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #384: void print_term_ln(Term term) { print_term(term); printf("\n"); } #385: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #386: // Evaluation // ---------- #387: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = ref_lab; u64 arity = HVM.fari[fun_id]; if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #388: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #389: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #390: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #391: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #392: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #393: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #394: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #395: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #398: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = HVM.fari[ref_lab]; Loc ref0 = ref_loc; Loc ref1 = alloc_node(ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #402: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #403: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #404: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #405: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #406: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #407: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #408: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #409: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #410: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #411: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #412: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #413: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #414: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #415: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #416: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #417: while (1) { #418: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #419: switch (tag) { #420: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #421: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #425: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #426: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #427: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #428: case REF: { next = reduce_ref(next); // TODO continue; } #429: default: { #430: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #431: case LET: { next = reduce_let(prev, next); continue; } #432: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #433: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #434: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #435: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #436: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #437: default: break; } break; } } } #438: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #439: } printf("retr: ERR\n"); return 0; } #440: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #441: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #442: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #443: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #444: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #445: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #446: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: default: return wnf; #449: } } #450: // Primitives // ---------- #451: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #452: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #453: } #454: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; HVM.fari[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 65536; i++) { HVM.book[i] = hvm->book[i]; HVM.fari[i] = hvm->fari[i]; HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_fari(u64 fid, u16 arity) { HVM.fari[fid] = arity; } #463: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #464: -- //./Type.hs// -- //./Inject.hs// #465: module HVML.Extract where #466: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #467: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #468: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host trace ("extract " ++ show host ++ " " ++ termToString term) $ case tagT (termTag term) of #469: ERA -> do return Era #470: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #471: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #472: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #473: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #474: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #475: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #476: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #477: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #478: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #479: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #480: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #481: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #482: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #483: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: REF -> do let loc = termLoc term let lab = termLab term let fid = lab let ari = funArity book fid let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #486: _ -> do return Era #487: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #488: -- Lifting Dups -- ------------ #489: liftDups :: Core -> (Core, Core -> Core) #490: liftDups (Var nam) = (Var nam, id) #491: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #492: liftDups Era = (Era, id) #493: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #494: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #495: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #496: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #497: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #498: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #499: liftDups (U32 val) = (U32 val, id) #500: liftDups (Chr val) = (Chr val, id) #501: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #502: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #503: liftDupsList :: [Core] -> ([Core], Core -> Core) #504: liftDupsList [] = ([], id) #505: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #506: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #507: liftDupsMov [] = ([], id) #508: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #509: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #510: liftDupsCss [] = ([], id) #511: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #512: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #513: -- //./Type.hs// #514: module HVML.Inject where #515: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #516: type InjectM a = StateT InjectState HVM a #517: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #518: emptyState :: InjectState emptyState = InjectState MS.empty [] #519: injectCore :: Book -> Core -> Loc -> InjectM () #520: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #521: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #522: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #523: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #524: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #525: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #526: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #527: injectCore book (Ref nam fid arg) loc = do let ari = funArity book fid ref <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ fid ref) #528: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #529: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #530: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #531: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #532: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #533: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

860bb428c30e00326b5408db1f5f6444d1b05a26

rename some fields for consistency

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] nameToId' = withPrims (MS.fromList nameList) idToName' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList nameToId')) idToFunc' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget nameToId' fn, ((cp, ars), lexify (setRefIds nameToId' cr)))) defs) idToLabs' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget nameToId' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { idToFunc = idToFunc' , idToName = idToName' , idToLabs = idToLabs' , nameToId = nameToId' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ")) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #273: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #274: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #275: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #276: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #277: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #278: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #279: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #280: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #281: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #282: -- Type.hs: -- //./Type.hs// #283: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #284: module Main where #285: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #286: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #287: -- Main -- ---- #288: data RunMode = Normalize | Collapse | Search deriving Eq #289: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #290: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #291: -- CLI Commands -- ------------ #292: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #293: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #294: module HVML.Type where #295: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #296: -- Core Types -- ---------- #297: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #298: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #299: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #300: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #301: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #302: data Book = Book { idToFunc :: MS.Map Word64 Func -- function id to Function object , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , idToName :: MS.Map Word64 String -- function id to name , nameToId :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #303: -- Runtime Types -- ------------- #304: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #305: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #306: --show-- type HVM = IO #307: --show-- type ReduceAt = Book -> Loc -> HVM Term #308: -- C Functions -- ----------- #309: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #310: -- Constants -- --------- #311: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #312: _DP0_ :: Tag _DP0_ = 0x00 #313: _DP1_ :: Tag _DP1_ = 0x01 #314: _VAR_ :: Tag _VAR_ = 0x02 #315: _SUB_ :: Tag _SUB_ = 0x03 #316: _REF_ :: Tag _REF_ = 0x04 #317: _LET_ :: Tag _LET_ = 0x05 #318: _APP_ :: Tag _APP_ = 0x06 #319: _MAT_ :: Tag _MAT_ = 0x08 #320: _IFL_ :: Tag _IFL_ = 0x09 #321: _SWI_ :: Tag _SWI_ = 0x0A #322: _OPX_ :: Tag _OPX_ = 0x0B #323: _OPY_ :: Tag _OPY_ = 0x0C #324: _ERA_ :: Tag _ERA_ = 0x0D #325: _LAM_ :: Tag _LAM_ = 0x0E #326: _SUP_ :: Tag _SUP_ = 0x0F #327: _CTR_ :: Tag _CTR_ = 0x10 #328: _W32_ :: Tag _W32_ = 0x11 #329: _CHR_ :: Tag _CHR_ = 0x12 #330: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #331: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #332: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #333: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #334: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #340: //./Type.hs// #341: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #342: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #343: // Runtime Types // ------------- #344: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #345: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #346: // Constants // --------- #347: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #348: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #349: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #350: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #351: #define VOID 0x00000000000000 #352: // Heap // ---- #353: Loc get_len() { return *HVM.size; } #354: u64 get_itr() { return *HVM.itrs; } #355: u64 fresh() { return (*HVM.frsh)++; } #356: void set_len(Loc value) { *HVM.size = value; } #357: void set_itr(Loc value) { *HVM.itrs = value; } #358: // Terms // ------ #359: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #360: Tag term_tag(Term x) { return x & 0x7F; } #361: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #362: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #363: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #364: Term term_set_bit(Term term) { return term | (1ULL << 7); } #365: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #366: } #367: // u12v2 // ----- #368: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #369: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #370: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #371: // Atomics // ------- #372: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #373: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #374: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #375: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #376: Term take(Loc loc) { return swap(loc, VOID); } #377: // Allocation // ---------- #378: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #379: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #380: // Stringification // --------------- #381: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #382: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #383: void print_term_ln(Term term) { print_term(term); printf("\n"); } #384: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #385: // Evaluation // ---------- #386: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #387: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #388: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #389: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #390: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #391: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #392: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #393: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #394: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #395: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #397: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #401: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #402: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #403: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #404: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #405: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #406: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #407: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #408: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #409: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #410: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #411: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #412: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #413: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #414: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #415: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #416: while (1) { #417: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #418: switch (tag) { #419: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #420: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #421: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #424: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #425: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #426: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #427: case REF: { next = reduce_ref(next); // TODO continue; } #428: default: { #429: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #430: case LET: { next = reduce_let(prev, next); continue; } #431: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #432: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #433: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #434: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #435: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #436: default: break; } break; } } } #437: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #438: } printf("retr: ERR\n"); return 0; } #439: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #440: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #441: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #442: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #443: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #444: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #445: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #446: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: default: return wnf; #448: } } #449: // Primitives // ---------- #450: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #451: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #452: } #453: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #454: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #463: -- //./Type.hs// -- //./Inject.hs// #464: module HVML.Extract where #465: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #466: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #467: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #468: ERA -> do return Era #469: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #470: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #471: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #472: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #473: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #474: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #475: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #476: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #477: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #478: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #479: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #481: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #482: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #483: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg #485: _ -> do return Era #486: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #487: -- Lifting Dups -- ------------ #488: liftDups :: Core -> (Core, Core -> Core) #489: liftDups (Var nam) = (Var nam, id) #490: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #491: liftDups Era = (Era, id) #492: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #493: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #494: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #495: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #496: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #497: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #498: liftDups (U32 val) = (U32 val, id) #499: liftDups (Chr val) = (Chr val, id) #500: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #501: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #502: liftDupsList :: [Core] -> ([Core], Core -> Core) #503: liftDupsList [] = ([], id) #504: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #505: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #506: liftDupsMov [] = ([], id) #507: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #508: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #509: liftDupsCss [] = ([], id) #510: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #511: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #512: -- //./Type.hs// #513: module HVML.Inject where #514: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #515: type InjectM a = StateT InjectState HVM a #516: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #517: emptyState :: InjectState emptyState = InjectState MS.empty [] #518: injectCore :: Book -> Core -> Loc -> InjectM () #519: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #520: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #521: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #522: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #523: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #524: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #525: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #526: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #527: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #528: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #529: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #530: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #531: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #532: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] namToFid' = withPrims (MS.fromList nameList) fidToNam' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList namToFid')) fidToFun' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget namToFid' fn, ((cp, ars), lexify (setRefIds namToFid' cr)))) defs) fidToLab' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget namToFid' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { fidToFun = fidToFun' , fidToNam = fidToNam' , fidToLab = fidToLab' , namToFid = namToFid' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (fidToFun book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (fidToNam book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (fidToFun book) fid)) in let args = snd (fst (mget (fidToFun book) fid)) in let core = snd (mget (fidToFun book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (fidToLab book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ")) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (fidToNam book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (fidToNam book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #273: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #274: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #275: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #276: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #277: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #278: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #279: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #280: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #281: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (fidToNam book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (fidToNam book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #282: -- Type.hs: -- //./Type.hs// #283: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #284: module Main where #285: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #286: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #287: -- Main -- ---- #288: data RunMode = Normalize | Collapse | Search deriving Eq #289: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #290: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #291: -- CLI Commands -- ------------ #292: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (fidToFun book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (fidToFun book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (fidToNam book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (namToFid book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (namToFid book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #293: genMain :: Book -> String genMain book = let mainFid = mget (namToFid book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (fidToNam book) fid ++ "_f);" | fid <- MS.keys (fidToFun book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #294: module HVML.Type where #295: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #296: -- Core Types -- ---------- #297: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #298: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #299: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #300: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #301: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #302: data Book = Book { fidToFun :: MS.Map Word64 Func -- function id to Function object , fidToLab :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , fidToNam :: MS.Map Word64 String -- function id to name , namToFid :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #303: -- Runtime Types -- ------------- #304: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #305: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #306: --show-- type HVM = IO #307: --show-- type ReduceAt = Book -> Loc -> HVM Term #308: -- C Functions -- ----------- #309: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #310: -- Constants -- --------- #311: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #312: _DP0_ :: Tag _DP0_ = 0x00 #313: _DP1_ :: Tag _DP1_ = 0x01 #314: _VAR_ :: Tag _VAR_ = 0x02 #315: _SUB_ :: Tag _SUB_ = 0x03 #316: _REF_ :: Tag _REF_ = 0x04 #317: _LET_ :: Tag _LET_ = 0x05 #318: _APP_ :: Tag _APP_ = 0x06 #319: _MAT_ :: Tag _MAT_ = 0x08 #320: _IFL_ :: Tag _IFL_ = 0x09 #321: _SWI_ :: Tag _SWI_ = 0x0A #322: _OPX_ :: Tag _OPX_ = 0x0B #323: _OPY_ :: Tag _OPY_ = 0x0C #324: _ERA_ :: Tag _ERA_ = 0x0D #325: _LAM_ :: Tag _LAM_ = 0x0E #326: _SUP_ :: Tag _SUP_ = 0x0F #327: _CTR_ :: Tag _CTR_ = 0x10 #328: _W32_ :: Tag _W32_ = 0x11 #329: _CHR_ :: Tag _CHR_ = 0x12 #330: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #331: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #332: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #333: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #334: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #340: //./Type.hs// #341: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #342: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #343: // Runtime Types // ------------- #344: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #345: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #346: // Constants // --------- #347: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #348: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #349: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #350: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #351: #define VOID 0x00000000000000 #352: // Heap // ---- #353: Loc get_len() { return *HVM.size; } #354: u64 get_itr() { return *HVM.itrs; } #355: u64 fresh() { return (*HVM.frsh)++; } #356: void set_len(Loc value) { *HVM.size = value; } #357: void set_itr(Loc value) { *HVM.itrs = value; } #358: // Terms // ------ #359: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #360: Tag term_tag(Term x) { return x & 0x7F; } #361: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #362: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #363: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #364: Term term_set_bit(Term term) { return term | (1ULL << 7); } #365: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #366: } #367: // u12v2 // ----- #368: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #369: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #370: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #371: // Atomics // ------- #372: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #373: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #374: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #375: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #376: Term take(Loc loc) { return swap(loc, VOID); } #377: // Allocation // ---------- #378: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #379: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #380: // Stringification // --------------- #381: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #382: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #383: void print_term_ln(Term term) { print_term(term); printf("\n"); } #384: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #385: // Evaluation // ---------- #386: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #387: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #388: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #389: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #390: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #391: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #392: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #393: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #394: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #395: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #397: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #401: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #402: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #403: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #404: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #405: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #406: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #407: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #408: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #409: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #410: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #411: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #412: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #413: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #414: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #415: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #416: while (1) { #417: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #418: switch (tag) { #419: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #420: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #421: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #424: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #425: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #426: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #427: case REF: { next = reduce_ref(next); // TODO continue; } #428: default: { #429: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #430: case LET: { next = reduce_let(prev, next); continue; } #431: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #432: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #433: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #434: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #435: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #436: default: break; } break; } } } #437: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #438: } printf("retr: ERR\n"); return 0; } #439: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #440: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #441: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #442: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #443: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #444: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #445: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #446: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: default: return wnf; #448: } } #449: // Primitives // ---------- #450: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #451: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #452: } #453: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #454: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #463: -- //./Type.hs// -- //./Inject.hs// #464: module HVML.Extract where #465: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #466: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #467: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #468: ERA -> do return Era #469: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #470: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #471: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #472: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #473: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #474: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #475: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #476: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #477: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #478: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #479: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #481: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #482: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #483: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (fidToNam book) return $ Ref name fid arg #485: _ -> do return Era #486: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #487: -- Lifting Dups -- ------------ #488: liftDups :: Core -> (Core, Core -> Core) #489: liftDups (Var nam) = (Var nam, id) #490: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #491: liftDups Era = (Era, id) #492: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #493: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #494: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #495: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #496: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #497: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #498: liftDups (U32 val) = (U32 val, id) #499: liftDups (Chr val) = (Chr val, id) #500: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #501: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #502: liftDupsList :: [Core] -> ([Core], Core -> Core) #503: liftDupsList [] = ([], id) #504: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #505: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #506: liftDupsMov [] = ([], id) #507: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #508: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #509: liftDupsCss [] = ([], id) #510: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #511: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #512: -- //./Type.hs// #513: module HVML.Inject where #514: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #515: type InjectM a = StateT InjectState HVM a #516: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #517: emptyState :: InjectState emptyState = InjectState MS.empty [] #518: injectCore :: Book -> Core -> Loc -> InjectM () #519: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #520: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #521: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #522: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #523: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #524: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #525: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #526: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #527: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #528: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #529: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #530: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #531: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #532: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

048c83f402846009766fc0d33afaf71aedd2a0a9

store only the cid on CTR lab field

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] nameToId' = withPrims (MS.fromList nameList) idToName' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList nameToId')) idToFunc' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget nameToId' fn, ((cp, ars), lexify (setRefIds nameToId' cr)))) defs) idToLabs' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget nameToId' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { idToFunc = idToFunc' , idToName = idToName' , idToLabs = idToLabs' , nameToId = nameToId' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: -- compileFastCore book fid tm@(Mat val mov css) reuse = do -- matNam <- fresh "mat" -- let cid = matFirstCid book tm -- let len = fromIntegral $ mget (cidToLen book) cid -- matLoc <- compileFastAlloc (1 + len) reuse -- emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" -- valT <- compileFastCore book fid val reuse -- emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" -- forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds -- bodT <- compileFastCore book fid bod' reuse -- emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- let lab = (cid `shiftL` 1) .|. matIsIfLet book tm -- let mat = "term_new(MAT, " ++ show lab ++ ", " ++ matNam ++ ")" -- foldM (\term (key, val) -> do -- appNam <- fresh "app" -- appLoc <- compileFastAlloc 2 reuse -- emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" -- valT <- compileFastCore book fid val reuse -- emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" -- emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" -- return $ "term_new(APP, 0, " ++ appNam ++ ")" -- ) mat mov #273: -- TODO: the code above is outdated. now, Mat constructors (Haskell side) become -- either MAT, IFL or SWO on C side. read the Inject code for Mat to understand -- that logic. then, update the compileFullCore case above. #274: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #275: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #276: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #277: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #278: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #279: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #280: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #281: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #282: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #283: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #284: -- Type.hs: -- //./Type.hs// #285: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #286: module Main where #287: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #288: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #289: -- Main -- ---- #290: data RunMode = Normalize | Collapse | Search deriving Eq #291: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #292: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #293: -- CLI Commands -- ------------ #294: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #295: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #296: module HVML.Type where #297: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #298: -- Core Types -- ---------- #299: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #300: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #301: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #302: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #303: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #304: data Book = Book { idToFunc :: MS.Map Word64 Func -- function id to Function object , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , idToName :: MS.Map Word64 String -- function id to name , nameToId :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #305: -- Runtime Types -- ------------- #306: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #307: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #308: --show-- type HVM = IO #309: --show-- type ReduceAt = Book -> Loc -> HVM Term #310: -- C Functions -- ----------- #311: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #312: -- Constants -- --------- #313: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #314: _DP0_ :: Tag _DP0_ = 0x00 #315: _DP1_ :: Tag _DP1_ = 0x01 #316: _VAR_ :: Tag _VAR_ = 0x02 #317: _SUB_ :: Tag _SUB_ = 0x03 #318: _REF_ :: Tag _REF_ = 0x04 #319: _LET_ :: Tag _LET_ = 0x05 #320: _APP_ :: Tag _APP_ = 0x06 #321: _MAT_ :: Tag _MAT_ = 0x08 #322: _IFL_ :: Tag _IFL_ = 0x09 #323: _SWI_ :: Tag _SWI_ = 0x0A #324: _OPX_ :: Tag _OPX_ = 0x0B #325: _OPY_ :: Tag _OPY_ = 0x0C #326: _ERA_ :: Tag _ERA_ = 0x0D #327: _LAM_ :: Tag _LAM_ = 0x0E #328: _SUP_ :: Tag _SUP_ = 0x0F #329: _CTR_ :: Tag _CTR_ = 0x10 #330: _W32_ :: Tag _W32_ = 0x11 #331: _CHR_ :: Tag _CHR_ = 0x12 #332: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #333: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #334: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #335: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #336: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #337: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #338: -- Utils -- ----- #339: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #340: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #341: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #342: //./Type.hs// #343: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #344: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #345: // Runtime Types // ------------- #346: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #347: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #348: // Constants // --------- #349: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #350: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #351: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #352: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #353: #define VOID 0x00000000000000 #354: // Heap // ---- #355: Loc get_len() { return *HVM.size; } #356: u64 get_itr() { return *HVM.itrs; } #357: u64 fresh() { return (*HVM.frsh)++; } #358: void set_len(Loc value) { *HVM.size = value; } #359: void set_itr(Loc value) { *HVM.itrs = value; } #360: // Terms // ------ #361: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #362: Tag term_tag(Term x) { return x & 0x7F; } #363: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #364: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #365: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #366: Term term_set_bit(Term term) { return term | (1ULL << 7); } #367: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #368: } #369: // u12v2 // ----- #370: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #371: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #372: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #373: // Atomics // ------- #374: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #375: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #376: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #377: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #378: Term take(Loc loc) { return swap(loc, VOID); } #379: // Allocation // ---------- #380: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #381: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #382: // Stringification // --------------- #383: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #384: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #385: void print_term_ln(Term term) { print_term(term); printf("\n"); } #386: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #387: // Evaluation // ---------- #388: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #389: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #390: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #391: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #392: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #393: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #394: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #395: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #396: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #399: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #403: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #404: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #405: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #406: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #407: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #408: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #409: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #410: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #411: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #412: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #413: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #414: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #415: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #416: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #417: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #418: while (1) { #419: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #420: switch (tag) { #421: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #422: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #425: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #426: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #427: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #428: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #429: case REF: { next = reduce_ref(next); // TODO continue; } #430: default: { #431: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #432: case LET: { next = reduce_let(prev, next); continue; } #433: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #434: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #435: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #436: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #437: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #438: default: break; } break; } } } #439: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #440: } printf("retr: ERR\n"); return 0; } #441: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #442: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #443: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #444: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #445: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #446: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #447: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #449: default: return wnf; #450: } } #451: // Primitives // ---------- #452: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #453: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #454: } #455: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #456: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #457: // Runtime Memory // -------------- #458: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #459: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #460: State* hvm_get_state() { return &HVM; } #461: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #462: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #463: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #464: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #465: -- //./Type.hs// -- //./Inject.hs// #466: module HVML.Extract where #467: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #468: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #469: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #470: ERA -> do return Era #471: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #472: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #473: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #474: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #475: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #476: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #477: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #478: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #479: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #481: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #482: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #483: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #484: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #486: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg #487: _ -> do return Era #488: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #489: -- Lifting Dups -- ------------ #490: liftDups :: Core -> (Core, Core -> Core) #491: liftDups (Var nam) = (Var nam, id) #492: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #493: liftDups Era = (Era, id) #494: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #495: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #496: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #497: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #498: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #499: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #500: liftDups (U32 val) = (U32 val, id) #501: liftDups (Chr val) = (Chr val, id) #502: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #503: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #504: liftDupsList :: [Core] -> ([Core], Core -> Core) #505: liftDupsList [] = ([], id) #506: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #507: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #508: liftDupsMov [] = ([], id) #509: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #510: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #511: liftDupsCss [] = ([], id) #512: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #513: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #514: -- //./Type.hs// #515: module HVML.Inject where #516: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #517: type InjectM a = StateT InjectState HVM a #518: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #519: emptyState :: InjectState emptyState = InjectState MS.empty [] #520: injectCore :: Book -> Core -> Loc -> InjectM () #521: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #522: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #523: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #524: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #525: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #526: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #527: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #528: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #529: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #530: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #531: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #532: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #533: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #534: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] nameToId' = withPrims (MS.fromList nameList) idToName' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList nameToId')) idToFunc' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget nameToId' fn, ((cp, ars), lexify (setRefIds nameToId' cr)))) defs) idToLabs' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget nameToId' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { idToFunc = idToFunc' , idToName = idToName' , idToLabs = idToLabs' , nameToId = nameToId' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (term_lab(" ++ valNam ++ ") == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (term_lab(" ++ valNam ++ ")) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #273: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #274: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #275: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #276: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #277: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #278: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #279: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #280: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #281: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #282: -- Type.hs: -- //./Type.hs// #283: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #284: module Main where #285: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #286: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #287: -- Main -- ---- #288: data RunMode = Normalize | Collapse | Search deriving Eq #289: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #290: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #291: -- CLI Commands -- ------------ #292: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #293: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #294: module HVML.Type where #295: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #296: -- Core Types -- ---------- #297: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #298: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #299: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #300: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #301: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #302: data Book = Book { idToFunc :: MS.Map Word64 Func -- function id to Function object , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , idToName :: MS.Map Word64 String -- function id to name , nameToId :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #303: -- Runtime Types -- ------------- #304: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #305: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #306: --show-- type HVM = IO #307: --show-- type ReduceAt = Book -> Loc -> HVM Term #308: -- C Functions -- ----------- #309: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #310: -- Constants -- --------- #311: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #312: _DP0_ :: Tag _DP0_ = 0x00 #313: _DP1_ :: Tag _DP1_ = 0x01 #314: _VAR_ :: Tag _VAR_ = 0x02 #315: _SUB_ :: Tag _SUB_ = 0x03 #316: _REF_ :: Tag _REF_ = 0x04 #317: _LET_ :: Tag _LET_ = 0x05 #318: _APP_ :: Tag _APP_ = 0x06 #319: _MAT_ :: Tag _MAT_ = 0x08 #320: _IFL_ :: Tag _IFL_ = 0x09 #321: _SWI_ :: Tag _SWI_ = 0x0A #322: _OPX_ :: Tag _OPX_ = 0x0B #323: _OPY_ :: Tag _OPY_ = 0x0C #324: _ERA_ :: Tag _ERA_ = 0x0D #325: _LAM_ :: Tag _LAM_ = 0x0E #326: _SUP_ :: Tag _SUP_ = 0x0F #327: _CTR_ :: Tag _CTR_ = 0x10 #328: _W32_ :: Tag _W32_ = 0x11 #329: _CHR_ :: Tag _CHR_ = 0x12 #330: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #331: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #332: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #333: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #334: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #335: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #336: -- Utils -- ----- #337: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #338: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #339: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #340: //./Type.hs// #341: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #342: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #343: // Runtime Types // ------------- #344: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #345: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #346: // Constants // --------- #347: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #348: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #349: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #350: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #351: #define VOID 0x00000000000000 #352: // Heap // ---- #353: Loc get_len() { return *HVM.size; } #354: u64 get_itr() { return *HVM.itrs; } #355: u64 fresh() { return (*HVM.frsh)++; } #356: void set_len(Loc value) { *HVM.size = value; } #357: void set_itr(Loc value) { *HVM.itrs = value; } #358: // Terms // ------ #359: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #360: Tag term_tag(Term x) { return x & 0x7F; } #361: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #362: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #363: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #364: Term term_set_bit(Term term) { return term | (1ULL << 7); } #365: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #366: } #367: // u12v2 // ----- #368: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #369: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #370: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #371: // Atomics // ------- #372: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #373: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #374: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #375: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #376: Term take(Loc loc) { return swap(loc, VOID); } #377: // Allocation // ---------- #378: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #379: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #380: // Stringification // --------------- #381: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #382: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #383: void print_term_ln(Term term) { print_term(term); printf("\n"); } #384: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #385: // Evaluation // ---------- #386: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #387: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #388: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #389: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #390: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #391: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #392: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #393: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #394: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #395: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #396: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #397: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #399: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #401: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #402: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #403: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #404: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #405: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #406: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #407: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #408: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #409: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #410: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #411: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #412: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #413: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #414: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #415: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #416: while (1) { #417: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #418: switch (tag) { #419: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #420: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #421: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #422: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #424: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #425: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #426: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #427: case REF: { next = reduce_ref(next); // TODO continue; } #428: default: { #429: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #430: case LET: { next = reduce_let(prev, next); continue; } #431: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #432: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #433: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #434: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #435: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #436: default: break; } break; } } } #437: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #438: } printf("retr: ERR\n"); return 0; } #439: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #440: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #441: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #442: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #443: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #444: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #445: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #446: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #447: default: return wnf; #448: } } #449: // Primitives // ---------- #450: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #451: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #452: } #453: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #454: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #455: // Runtime Memory // -------------- #456: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #457: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #458: State* hvm_get_state() { return &HVM; } #459: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #460: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #461: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #462: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #463: -- //./Type.hs// -- //./Inject.hs// #464: module HVML.Extract where #465: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #466: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #467: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #468: ERA -> do return Era #469: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #470: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #471: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #472: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #473: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #474: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #475: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #476: CTR -> do let loc = termLoc term let lab = termLab term let cid = lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #477: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #478: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #479: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #481: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #482: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #483: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #484: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg #485: _ -> do return Era #486: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #487: -- Lifting Dups -- ------------ #488: liftDups :: Core -> (Core, Core -> Core) #489: liftDups (Var nam) = (Var nam, id) #490: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #491: liftDups Era = (Era, id) #492: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #493: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #494: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #495: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #496: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #497: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #498: liftDups (U32 val) = (U32 val, id) #499: liftDups (Chr val) = (Chr val, id) #500: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #501: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #502: liftDupsList :: [Core] -> ([Core], Core -> Core) #503: liftDupsList [] = ([], id) #504: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #505: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #506: liftDupsMov [] = ([], id) #507: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #508: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #509: liftDupsCss [] = ([], id) #510: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #511: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #512: -- //./Type.hs// #513: module HVML.Inject where #514: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #515: type InjectM a = StateT InjectState HVM a #516: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #517: emptyState :: InjectState emptyState = InjectState MS.empty [] #518: injectCore :: Book -> Core -> Loc -> InjectM () #519: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #520: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #521: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #522: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #523: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #524: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #525: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #526: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #527: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #528: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #529: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #530: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #531: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #532: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

bb38ab9ea4e986f936388fdaa70847900dbe472b

refactor CTR/MAT to include just the CID

./Collapse.hs #1: module HVML.Collapse where #2: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS import Debug.Trace #3: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #4: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #5: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #6: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #7: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #8: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #9: instance Applicative Collapse where pure = CVal (<*>) = ap #10: instance Monad Collapse where return = pure (>>=) = bind #11: -- Dup Collapser -- ------------- #12: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #13: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #14: ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #26: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #28: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #29: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core #32: collapseSups book core = case core of #33: Var name -> do return $ Var name #34: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #35: Lam name body -> do body <- collapseSups book body return $ Lam name body #36: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #37: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #38: Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields #39: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #40: U32 val -> do return $ U32 val #41: Chr val -> do return $ Chr val #42: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #43: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #44: Era -> do CEra #45: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #46: -- Tree Collapser -- -------------- #47: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #48: -- Priority Queue -- -------------- #49: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #50: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #51: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #52: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #53: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #54: data SQ a = SQ [a] [a] #55: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #56: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #57: -- Flattener -- --------- #58: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #59: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #60: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #61: flatten :: Collapse a -> [a] flatten = flattenBFS #62: -- Flat Collapser -- -------------- #63: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #64: -- //./Type.hs// #65: module HVML.Show where #66: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #67: -- Core Stringification -- -------------------- #68: showCore :: Core -> String showCore = coreToString . prettyRename #69: coreToString :: Core -> String coreToString core = #70: case pretty core of Just str -> str Nothing -> case core of #71: Var nam -> nam #72: Era -> "*" #73: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #74: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #75: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #76: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #77: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #78: Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" #79: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #80: U32 val -> show val #81: Chr val -> "'" ++ [val] ++ "'" #82: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #83: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #84: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #85: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #86: -- Runtime Stringification -- ----------------------- #87: tagToString :: Tag -> String tagToString t = show (tagT t) #88: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #89: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #90: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #91: -- Pretty Renaming -- --------------- #92: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #93: go namesRef core = case core of #94: Var name -> do name' <- genName namesRef name return $ Var name' #95: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #96: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #97: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #98: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #99: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #100: Ctr cid args -> do args' <- mapM (go namesRef) args return $ Ctr cid args' #101: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #102: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #103: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #104: other -> return other #105: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #106: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #107: -- Pretty Printers -- --------------- #108: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #109: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #110: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #111: -- Dumping -- ------- #112: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #113: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #114: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #115: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #116: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #117: -- //./Type.hs// #118: module HVML.Parse where #119: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #120: -- Core Parsers -- ------------ #121: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #122: type ParserM = Parsec String ParserState #123: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #124: '*' -> do consume "*" return Era #125: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #126: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #127: '@' -> do parseRef #128: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #129: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #130: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #131: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #132: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #133: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #134: '#' -> parseCtr #135: '~' -> parseMat #136: '[' -> parseLst #137: '\'' -> parseChr #138: '"' -> parseStr #139: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #140: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #141: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #142: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #143: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #144: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #145: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #146: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #147: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #148: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #149: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #150: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #151: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #152: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #153: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #154: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #155: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #156: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #157: -- Helper Parsers -- -------------- #158: consume :: String -> ParserM String consume str = skip >> string str #159: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #160: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #161: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #162: -- Adjusting -- --------- #163: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #164: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #165: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #166: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #167: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #168: go :: Core -> MS.Map String String -> State Int Core #169: go term ctx = case term of #170: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #171: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #172: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #173: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #174: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #175: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #176: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #177: Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds #178: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #179: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #180: U32 n -> return $ U32 n #181: Chr c -> return $ Chr c #182: Era -> return Era #183: -- Errors -- ------ #184: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #185: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #186: -- //./Type.hs// #187: module HVML.Reduce where #188: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #189: reduceAt :: Bool -> ReduceAt #190: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #191: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #192: case tagT tag of #193: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #194: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #195: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #196: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #197: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #198: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #199: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #200: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #201: REF -> do reduceRefAt book host reduceAt debug book host #202: otherwise -> do return term #203: where cont host action = do ret <- action set host ret reduceAt debug book host #204: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #205: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #206: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #207: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #208: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #209: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #210: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #211: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #212: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #213: -- //./Type.hs// -- //./Reduce.hs// #214: module HVML.Compile where #215: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #216: -- Compilation -- ----------- #217: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #218: type Compile = State CompileState #219: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #220: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #221: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #222: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #223: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #224: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #225: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #226: -- Full Compiler -- ------------- #227: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #228: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #229: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #230: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #231: compileFullCore book fid (Var name) host = do compileFullVar name host #232: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #233: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #234: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #235: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #236: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #237: compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" #238: compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov #239: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #240: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #241: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #242: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #243: -- Fast Compiler -- ------------- #244: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #245: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #246: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #247: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #248: -- Constructor Pattern-Matching (with IfLet) else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #249: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #250: compileFastUndo book fid term ctx itr reuse #251: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #252: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #253: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #254: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #255: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #256: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #257: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #258: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #259: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #260: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #261: compileFastCore book fid (Var name) reuse = do compileFastVar name #262: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #263: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #264: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #265: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #266: compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" #267: compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov #268: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #269: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #270: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #271: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #272: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #273: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #274: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #275: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #276: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #277: -- Type.hs: -- //./Type.hs// #278: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #279: module Main where #280: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #281: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #282: -- Main -- ---- #283: data RunMode = Normalize | Collapse | Search deriving Eq #284: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #285: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #286: -- CLI Commands -- ------------ #287: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #288: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #289: module HVML.Type where #290: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #291: -- Core Types -- ---------- #292: --X-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #293: --X-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #294: --X-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #295: --X-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #296: --X-- -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #297: -- Runtime Types -- ------------- #298: --X-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #299: --X-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #300: --X-- type HVM = IO #301: --X-- type ReduceAt = Book -> Loc -> HVM Term #302: -- C Functions -- ----------- #303: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #304: -- Constants -- --------- #305: --X-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #306: _DP0_ :: Tag _DP0_ = 0x00 #307: _DP1_ :: Tag _DP1_ = 0x01 #308: _VAR_ :: Tag _VAR_ = 0x02 #309: _SUB_ :: Tag _SUB_ = 0x03 #310: _REF_ :: Tag _REF_ = 0x04 #311: _LET_ :: Tag _LET_ = 0x05 #312: _APP_ :: Tag _APP_ = 0x06 #313: _MAT_ :: Tag _MAT_ = 0x08 #314: _OPX_ :: Tag _OPX_ = 0x09 #315: _OPY_ :: Tag _OPY_ = 0x0A #316: _ERA_ :: Tag _ERA_ = 0x0B #317: _LAM_ :: Tag _LAM_ = 0x0C #318: _SUP_ :: Tag _SUP_ = 0x0D #319: _CTR_ :: Tag _CTR_ = 0x0F #320: _W32_ :: Tag _W32_ = 0x10 #321: _CHR_ :: Tag _CHR_ = 0x11 #322: --X-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #323: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #324: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #325: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #326: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #327: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #328: -- Utils -- ----- #329: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #330: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #331: //./Type.hs// #332: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #333: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #334: // Runtime Types // ------------- #335: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #336: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #337: // Constants // --------- #338: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #339: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #340: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #341: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #342: #define VOID 0x00000000000000 #343: // Heap // ---- #344: Loc get_len() { return *HVM.size; } #345: u64 get_itr() { return *HVM.itrs; } #346: u64 fresh() { return (*HVM.frsh)++; } #347: void set_len(Loc value) { *HVM.size = value; } #348: void set_itr(Loc value) { *HVM.itrs = value; } #349: // Terms // ------ #350: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #351: Tag term_tag(Term x) { return x & 0x7F; } #352: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #353: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #354: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #355: Term term_set_bit(Term term) { return term | (1ULL << 7); } #356: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #357: } #358: // u12v2 // ----- #359: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #360: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #361: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #362: // Atomics // ------- #363: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #364: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #365: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #366: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #367: Term take(Loc loc) { return swap(loc, VOID); } #368: // Allocation // ---------- #369: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #370: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #371: // Stringification // --------------- #372: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #373: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #374: void print_term_ln(Term term) { print_term(term); printf("\n"); } #375: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #376: // Evaluation // ---------- #377: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #378: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #379: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #380: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #381: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #382: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #383: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #384: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #385: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #386: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #387: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #388: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #389: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #390: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #391: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #392: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #393: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #394: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #395: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #396: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #397: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #398: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #399: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #400: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #401: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #402: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #403: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #404: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #405: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #406: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #407: while (1) { #408: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #409: switch (tag) { #410: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } #411: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #412: case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #413: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #414: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #415: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #416: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #417: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #418: case REF: { next = reduce_ref(next); // TODO continue; } #419: default: { #420: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #421: case LET: { next = reduce_let(prev, next); continue; } #422: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #423: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #424: case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #425: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #426: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #427: default: break; } break; } } } #428: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #429: } printf("retr: ERR\n"); return 0; } #430: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #431: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #432: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #433: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #434: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #435: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #436: case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #437: case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #438: default: return wnf; #439: } } #440: // Primitives // ---------- #441: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #442: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #443: } #444: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #445: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #446: // Runtime Memory // -------------- #447: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #448: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #449: State* hvm_get_state() { return &HVM; } #450: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #451: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #452: -- //./Type.hs// #453: module HVML.Extract where #454: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS import Debug.Trace #455: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #456: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #457: ERA -> do return Era #458: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #459: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #460: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #461: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #462: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #463: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #464: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #465: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr cid fds #466: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css #467: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #468: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #469: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #470: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #471: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg #472: _ -> do return Era #473: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #474: -- Lifting Dups -- ------------ #475: liftDups :: Core -> (Core, Core -> Core) #476: liftDups (Var nam) = (Var nam, id) #477: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #478: liftDups Era = (Era, id) #479: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #480: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #481: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #482: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #483: liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) #484: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #485: liftDups (U32 val) = (U32 val, id) #486: liftDups (Chr val) = (Chr val, id) #487: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #488: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #489: liftDupsList :: [Core] -> ([Core], Core -> Core) #490: liftDupsList [] = ([], id) #491: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #492: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #493: liftDupsMov [] = ([], id) #494: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #495: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #496: liftDupsCss [] = ([], id) #497: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #498: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #499: -- //./Type.hs// #500: module HVML.Inject where #501: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #502: type InjectM a = StateT InjectState HVM a #503: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #504: emptyState :: InjectState emptyState = InjectState Map.empty [] #505: injectCore :: Book -> Core -> Loc -> InjectM () #506: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #507: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #508: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #509: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #510: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #511: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #512: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #513: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #514: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #515: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #516: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #517: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #518: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #519: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Extract.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core #14: collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #15: ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #21: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #22: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #23: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let nam = MS.findWithDefault "?" cid (cidToCtr book) let ari = mget (cidToAri book) cid let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr nam fds0 #24: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (ctr, fds, bod0) return $ Mat val0 [] css0 #25: IFL -> do let loc = termLoc term let lab = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) cs00 <- collapseDupsAt state reduceAt book (loc + 1) cs10 <- collapseDupsAt state reduceAt book (loc + 2) return $ Mat val0 [] [(mget (cidToCtr book) lab, [], cs00), ("_", [], cs10)] #26: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM [0..len-1] $ \i -> do bod0 <- collapseDupsAt state reduceAt book (loc + 1 + i) return (show i, [], bod0) return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #33: -- Sup Collapser -- ------------- #34: collapseSups :: Book -> Core -> Collapse Core #35: collapseSups book core = case core of #36: Var name -> do return $ Var name #37: Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args #38: Lam name body -> do body <- collapseSups book body return $ Lam name body #39: App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg #40: Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body #41: Ctr nam fields -> do fields <- mapM (collapseSups book) fields return $ Ctr nam fields #42: Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css #43: U32 val -> do return $ U32 val #44: Chr val -> do return $ Chr val #45: Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y #46: Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #47: Era -> do CEra #48: Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #49: -- Tree Collapser -- -------------- #50: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #51: -- Priority Queue -- -------------- #52: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #53: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #54: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #55: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #56: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #57: data SQ a = SQ [a] [a] #58: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #59: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #60: -- Flattener -- --------- #61: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #62: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #63: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #64: flatten :: Collapse a -> [a] flatten = flattenBFS #65: -- Flat Collapser -- -------------- #66: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #67: -- //./Type.hs// #68: module HVML.Show where #69: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #70: -- Core Stringification -- -------------------- #71: showCore :: Core -> String showCore = coreToString . prettyRename #72: coreToString :: Core -> String coreToString core = #73: case pretty core of Just str -> str Nothing -> case core of #74: Var nam -> nam #75: Era -> "*" #76: Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' #77: App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" #78: Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" #79: Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' #80: Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" #81: Ctr nam fds -> let fds' = unwords (map coreToString fds) in "#" ++ nam ++ "{" ++ fds' ++ "}" #82: Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" #83: U32 val -> show val #84: Chr val -> "'" ++ [val] ++ "'" #85: Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" #86: Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #87: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #88: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #89: -- Runtime Stringification -- ----------------------- #90: tagToString :: Tag -> String tagToString t = show (tagT t) #91: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #92: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #93: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #94: -- Pretty Renaming -- --------------- #95: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where #96: go namesRef core = case core of #97: Var name -> do name' <- genName namesRef name return $ Var name' #98: Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' #99: Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' #100: App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' #101: Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' #102: Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' #103: Ctr nam args -> do args' <- mapM (go namesRef) args return $ Ctr nam args' #104: Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' #105: Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' #106: Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' #107: other -> return other #108: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName #109: genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #110: -- Pretty Printers -- --------------- #111: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #112: prettyStr :: Core -> Maybe String prettyStr (Ctr "Nil" []) = Just "\"\"" prettyStr (Ctr "Cons" [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #113: prettyLst :: Core -> Maybe String prettyLst (Ctr "Nil" []) = Just "[]" prettyLst (Ctr "Cons" [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #114: -- Dumping -- ------- #115: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #116: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #117: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #118: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #119: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #120: -- //./Type.hs// #121: module HVML.Parse where #122: import Control.Monad (foldM, forM, forM_, when) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #123: -- Core Parsers -- ------------ #124: data ParserState = ParserState { pCidToAri :: MS.Map Word64 Word64 , pCidToLen :: MS.Map Word64 Word64 , pCtrToCid :: MS.Map String Word64 , pCidToADT :: MS.Map Word64 Word64 , freshLabel :: Word64 } #125: type ParserM = Parsec String ParserState #126: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of #127: '*' -> do consume "*" return Era #128: 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod #129: '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args #130: '@' -> do parseRef #131: '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) #132: '!' -> do consume "!" skip next <- lookAhead anyChar case next of #133: '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] #134: '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod #135: '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod #136: _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod #137: '#' -> parseCtr #138: '~' -> parseMat #139: '[' -> parseLst #140: '\'' -> parseChr #141: '"' -> parseStr #142: _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #143: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #144: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr nam fds #145: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (pCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css -- Transform matches with default cases into nested chain of matches if (let (ctr, _, _) = head css in ctr == "0") then do return $ Mat val mov css else if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #146: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #147: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #148: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #149: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #150: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr "Cons" [Chr c, acc]) (Ctr "Nil" []) str #151: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr "Cons" [x, acc]) (Ctr "Nil" []) elems #152: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #153: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #154: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore -- trace ("parsed: " ++ showCore core) $ return (name, ((copy,args), core)) #155: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" st <- getState let baseCid = fromIntegral $ MS.size (pCtrToCid st) let ctrToCid = zip (map fst constructors) [baseCid..] let cidToAri = map (\(ctr, cid) -> (cid, fromIntegral . length . snd $ head $ filter ((== ctr) . fst) constructors)) ctrToCid let cidToLen = (baseCid, fromIntegral $ length constructors) let cidToADT = map (\(_, cid) -> (cid, baseCid)) ctrToCid modifyState (\s -> s { pCtrToCid = MS.union (MS.fromList ctrToCid) (pCtrToCid s), pCidToAri = MS.union (MS.fromList cidToAri) (pCidToAri s), pCidToLen = MS.insert (fst cidToLen) (snd cidToLen) (pCidToLen s), pCidToADT = MS.union (MS.fromList cidToADT) (pCidToADT s) }) #156: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName st <- getState when (MS.member name (pCtrToCid st)) $ do fail $ "Constructor '" ++ name ++ "' redefined" fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #157: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #158: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right core -> do return core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #159: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (pCtrToCid st) (pCidToAri st) (pCidToLen st) (pCidToADT st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #160: -- Helper Parsers -- -------------- #161: consume :: String -> ParserM String consume str = skip >> string str #162: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #163: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #164: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #165: -- Adjusting -- --------- #166: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> MS.Map Word64 Word64 -> Book createBook defs ctrToCid cidToAri cidToLen cidToADT = let withPrims = \n2i -> MS.union n2i (MS.fromList primitives) nameList = zip (map fst defs) (map fromIntegral [0..]) :: [(String, Word64)] nameToId' = withPrims (MS.fromList nameList) idToName' = MS.fromList (map (\(k,v) -> (v,k)) (MS.toList nameToId')) idToFunc' = MS.fromList (map (\(fn, ((cp,ars), cr)) -> (mget nameToId' fn, ((cp, ars), lexify (setRefIds nameToId' cr)))) defs) idToLabs' = MS.fromList (map (\(fn, ((_, _), cr)) -> (mget nameToId' fn, collectLabels cr)) defs) cidToCtr' = MS.fromList (map (\(ctr, cid) -> (cid, ctr)) (MS.toList ctrToCid)) in Book { idToFunc = idToFunc' , idToName = idToName' , idToLabs = idToLabs' , nameToId = nameToId' , cidToAri = cidToAri , cidToCtr = cidToCtr' , ctrToCid = ctrToCid , cidToLen = cidToLen , cidToADT = cidToADT } #167: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr nam fds -> Ctr nam (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #168: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #169: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #170: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #171: go :: Core -> MS.Map String String -> State Int Core #172: go term ctx = case term of #173: Var nam -> return $ Var (MS.findWithDefault nam nam ctx) #174: Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg #175: Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod #176: Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod #177: App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg #178: Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 #179: Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod #180: Ctr nam fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr nam fds #181: Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' #182: Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 #183: U32 n -> return $ U32 n #184: Chr c -> return $ Chr c #185: Era -> return Era #186: -- Errors -- ------ #187: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let msgs = errorMessages err failMsg = [msg | Message msg <- msgs] expectedMsgs = [msg | Expect msg <- msgs, msg /= "space", msg /= "Comment"] in if not (null failMsg) then head failMsg else if null expectedMsgs then "syntax error" else intercalate " | " expectedMsgs #188: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] if any isMessage (errorMessages err) then putStrLn $ "- " ++ errorMsg else do putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] where isMessage (Message _) = True isMessage _ = False ./Reduce.hs #189: -- //./Type.hs// #190: module HVML.Reduce where #191: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #192: reduceAt :: Bool -> ReduceAt #193: reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term #194: when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) #195: case tagT tag of #196: LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" #197: APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term #198: MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #199: IFL -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #200: SWI -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term #201: OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term #202: OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term #203: DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host #204: DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host #205: VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host #206: REF -> do reduceRefAt book host reduceAt debug book host #207: otherwise -> do return term #208: where cont host action = do ret <- action set host ret reduceAt debug book host #209: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #210: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #211: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #212: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #213: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #214: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #215: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #216: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #217: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #218: -- //./Type.hs// -- //./Inject.hs// #219: module HVML.Compile where #220: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.List import Data.Word import Debug.Trace import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #221: -- Compilation -- ----------- #222: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #223: type Compile = State CompileState #224: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #225: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #226: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #227: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #228: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #229: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #230: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #231: -- Full Compiler -- ------------- #232: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #233: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #234: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String #235: compileFullCore book fid Era _ = do return $ "term_new(ERA, 0, 0)" #236: compileFullCore book fid (Var name) host = do compileFullVar name host #237: compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" #238: compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #239: compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #240: compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #241: compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT #242: compileFullCore book fid (Ctr nam fds) host = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #243: compileFullCore book fid tm@(Mat val mov css) host = do let typ = matType book tm matNam <- fresh "mat" emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + length css) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" emit $ acc ++ " = term_new(APP, 0, " ++ appNam ++ ");" return acc) retNam mov return retNam #244: compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #245: compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #246: compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" #247: compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #248: -- Fast Compiler -- ------------- #249: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #250: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #251: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") #252: -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #253: -- Constructor Pattern-Matching (with IfLet) else do if matType book term == IfLet then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (matFirstCid book term) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" #254: -- Constructor Pattern-Matching (without IfLet) else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" #255: compileFastUndo book fid term ctx itr reuse #256: compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse #257: compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse #258: compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" #259: compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #260: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #261: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #262: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #263: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String #264: compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" #265: compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse #266: compileFastCore book fid (Var name) reuse = do compileFastVar name #267: compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" #268: compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" #269: compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" #270: compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse #271: compileFastCore book fid (Ctr nam fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds let cid = mget (ctrToCid book) nam ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, " ++ show cid ++ ", " ++ ctrNam ++ ")" #272: -- compileFastCore book fid tm@(Mat val mov css) reuse = do -- matNam <- fresh "mat" -- let cid = matFirstCid book tm -- let len = fromIntegral $ mget (cidToLen book) cid -- matLoc <- compileFastAlloc (1 + len) reuse -- emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" -- valT <- compileFastCore book fid val reuse -- emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" -- forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds -- bodT <- compileFastCore book fid bod' reuse -- emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- let lab = (cid `shiftL` 1) .|. matIsIfLet book tm -- let mat = "term_new(MAT, " ++ show lab ++ ", " ++ matNam ++ ")" -- foldM (\term (key, val) -> do -- appNam <- fresh "app" -- appLoc <- compileFastAlloc 2 reuse -- emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" -- valT <- compileFastCore book fid val reuse -- emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" -- emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" -- return $ "term_new(APP, 0, " ++ appNam ++ ")" -- ) mat mov #273: -- TODO: the code above is outdated. now, Mat constructors (Haskell side) become -- either MAT, IFL or SWO on C side. read the Inject code for Mat to understand -- that logic. then, update the compileFullCore case above. #274: compileFastCore book fid tm@(Mat val mov css) reuse = do let typ = matType book tm matNam <- fresh "mat" matLoc <- compileFastAlloc (1 + length css) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \(i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let tag = case typ of { Switch -> "SWI" ; IfLet -> "IFL" ; Match -> "MAT" } let lab = case typ of { Switch -> fromIntegral (length css) ; _ -> matFirstCid book tm } retNam <- fresh "ret" emit $ "Term " ++ retNam ++ " = term_new(" ++ tag ++ ", " ++ show lab ++ ", " ++ matNam ++ ");" foldM (\acc (_, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" emit $ "set(" ++ appNam ++ " + 0, " ++ acc ++ ");" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")") retNam mov #275: compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" #276: compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" #277: compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam #278: compileFastCore book fid (Ref rNam rFid rArg) reuse = do #279: -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" #280: -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse #281: -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #282: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #283: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #284: -- Type.hs: -- //./Type.hs// #285: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #286: module Main where #287: import Control.Monad (when, forM_) import Data.FileEmbed import Data.Time.Clock import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import GHC.Conc import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #288: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #289: -- Main -- ---- #290: data RunMode = Normalize | Collapse | Search deriving Eq #291: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #292: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #293: -- CLI Commands -- ------------ #294: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Set constructor arities, case length and ADT ids forM_ (MS.toList (cidToAri book)) $ \(cid, ari) -> do hvmSetCari cid (fromIntegral ari) forM_ (MS.toList (cidToLen book)) $ \(cid, len) -> do hvmSetClen cid (fromIntegral len) forM_ (MS.toList (cidToADT book)) $ \(cid, adt) -> do hvmSetCadt cid (fromIntegral adt) -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) when (mode /= Normalize) $ do putStrLn "" -- Prints total time end <- getCPUTime -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () -- Finalize hvmFree return $ Right () #295: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #296: module HVML.Type where #297: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #298: -- Core Types -- ---------- #299: --show-- data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr String [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #300: --show-- data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #301: --show-- data MatchType = Switch | Match | IfLet deriving (Show, Eq, Enum) #302: --show-- data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #303: --show-- -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #304: data Book = Book { idToFunc :: MS.Map Word64 Func -- function id to Function object , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) -- function id to dup labels used in its body , idToName :: MS.Map Word64 String -- function id to name , nameToId :: MS.Map String Word64 -- function name to id , cidToAri :: MS.Map Word64 Word64 -- constructor id to field count (arity) , cidToLen :: MS.Map Word64 Word64 -- constructor id to cases length (ADT constructor count) , cidToCtr :: MS.Map Word64 String -- constructor id to name , ctrToCid :: MS.Map String Word64 -- constructor name to id , cidToADT :: MS.Map Word64 Word64 -- constructor id to ADT id (first cid of its datatype) } deriving (Show, Eq) #305: -- Runtime Types -- ------------- #306: --show-- type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #307: --show-- data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | IFL | SWI | W32 | CHR | OPX | OPY deriving (Eq, Show) #308: --show-- type HVM = IO #309: --show-- type ReduceAt = Book -> Loc -> HVM Term #310: -- C Functions -- ----------- #311: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 foreign import ccall unsafe "Runtime.c hvm_set_cari" hvmSetCari :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_clen" hvmSetClen :: Word64 -> Word16 -> IO () foreign import ccall unsafe "Runtime.c hvm_set_cadt" hvmSetCadt :: Word64 -> Word16 -> IO () #312: -- Constants -- --------- #313: --show-- tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = IFL tagT 0x0A = SWI tagT 0x0B = OPX tagT 0x0C = OPY tagT 0x0D = ERA tagT 0x0E = LAM tagT 0x0F = SUP tagT 0x10 = CTR tagT 0x11 = W32 tagT 0x12 = CHR tagT tag = error $ "unknown tag: " ++ show tag #314: _DP0_ :: Tag _DP0_ = 0x00 #315: _DP1_ :: Tag _DP1_ = 0x01 #316: _VAR_ :: Tag _VAR_ = 0x02 #317: _SUB_ :: Tag _SUB_ = 0x03 #318: _REF_ :: Tag _REF_ = 0x04 #319: _LET_ :: Tag _LET_ = 0x05 #320: _APP_ :: Tag _APP_ = 0x06 #321: _MAT_ :: Tag _MAT_ = 0x08 #322: _IFL_ :: Tag _IFL_ = 0x09 #323: _SWI_ :: Tag _SWI_ = 0x0A #324: _OPX_ :: Tag _OPX_ = 0x0B #325: _OPY_ :: Tag _OPY_ = 0x0C #326: _ERA_ :: Tag _ERA_ = 0x0D #327: _LAM_ :: Tag _LAM_ = 0x0E #328: _SUP_ :: Tag _SUP_ = 0x0F #329: _CTR_ :: Tag _CTR_ = 0x10 #330: _W32_ :: Tag _W32_ = 0x11 #331: _CHR_ :: Tag _CHR_ = 0x12 #332: --show-- modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #333: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #334: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #335: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #336: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #337: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #338: -- Utils -- ----- #339: -- Getter function for maps -- TODO: add the type annotatino for mget mget :: (Ord k, Show k) => MS.Map k a -> k -> a mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #340: -- Returns the first constructor ID in a pattern-match matFirstCid :: Book -> Core -> Word64 matFirstCid book (Mat _ _ ((ctr,_,_):_)) = case MS.lookup ctr (ctrToCid book) of Just cid -> cid Nothing -> 0 matFirstCid _ _ = 0 #341: matType :: Book -> Core -> MatchType matType book (Mat _ _ css) = case css of ((ctr,_,_):_) | ctr == "0" -> Switch [(ctr,_,_),("_",_,_)] -> IfLet cs | all (\(c,_,_) -> c /= "_") cs -> Match _ -> error "invalid match" matType _ _ = error "not a match" ./Runtime.c #342: //./Type.hs// #343: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #344: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef _Atomic(Term) ATerm; #345: // Runtime Types // ------------- #346: typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions u16 cari[65536]; // arity of each constructor u16 clen[65536]; // case length of each constructor u16 cadt[65536]; // ADT id of each constructor } State; #347: static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL}, .cari = {0}, .clen = {0}, .cadt = {0}, }; #348: // Constants // --------- #349: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define IFL 0x09 #define SWI 0x0A #define OPX 0x0B #define OPY 0x0C #define ERA 0x0D #define LAM 0x0E #define SUP 0x0F #define CTR 0x10 #define W32 0x11 #define CHR 0x12 #350: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #351: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #352: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #353: #define VOID 0x00000000000000 #354: // Heap // ---- #355: Loc get_len() { return *HVM.size; } #356: u64 get_itr() { return *HVM.itrs; } #357: u64 fresh() { return (*HVM.frsh)++; } #358: void set_len(Loc value) { *HVM.size = value; } #359: void set_itr(Loc value) { *HVM.itrs = value; } #360: // Terms // ------ #361: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #362: Tag term_tag(Term x) { return x & 0x7F; } #363: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #364: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #365: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #366: Term term_set_bit(Term term) { return term | (1ULL << 7); } #367: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #368: } #369: // u12v2 // ----- #370: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #371: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #372: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #373: // Atomics // ------- #374: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #375: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #376: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #377: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #378: Term take(Loc loc) { return swap(loc, VOID); } #379: // Allocation // ---------- #380: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #381: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #382: // Stringification // --------------- #383: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case IFL: printf("IFL"); break; case SWI: printf("SWI"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #384: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #385: void print_term_ln(Term term) { print_term(term); printf("\n"); } #386: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #387: // Evaluation // ---------- #388: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #389: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #390: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #391: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #392: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #393: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #394: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #395: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #396: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #397: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #398: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #399: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = HVM.cari[ctr_lab]; //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #400: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #401: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #402: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #403: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #404: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Tag mat_tag = term_tag(mat); Lab mat_lab = term_lab(mat); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); u64 mat_len = mat_tag == SWI ? mat_lab : mat_tag == IFL ? 2 : HVM.clen[mat_lab]; Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(mat_tag, mat_lab, mat0)); set(sup0 + 1, term_new(mat_tag, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #405: Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Tag mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (mat_tag == IFL) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = mat_lab; u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = ctr_lab; u64 ctr_ari = HVM.cari[ctr_num]; u64 adt_id = HVM.cadt[ctr_num]; u64 mat_ctr = mat_lab; u64 cse_idx = ctr_num - mat_ctr; Term app = got(mat_loc + 1 + cse_idx); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #406: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = mat_lab; u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #407: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #408: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #409: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #410: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #411: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #412: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #413: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #414: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #415: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #416: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #417: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; #418: while (1) { #419: //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); #420: switch (tag) { #421: case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case PARA: { printf("TODO\n"); continue; } } } #422: case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #423: case MAT: case IFL: case SWI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #424: case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } #425: case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } #426: case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } #427: case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } #428: case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } #429: case REF: { next = reduce_ref(next); // TODO continue; } #430: default: { #431: if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { #432: case LET: { next = reduce_let(prev, next); continue; } #433: case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } #434: case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } #435: case MAT: case IFL: case SWI: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } #436: case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } #437: case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } #438: default: break; } break; } } } #439: if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case LET: set(hloc + 0, next); break; case MAT: case IFL: case SWI: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } #440: } printf("retr: ERR\n"); return 0; } #441: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #442: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { #443: case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } #444: case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } #445: case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } #446: case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } #447: case CTR: { u64 cid = lab; u64 ari = HVM.cari[cid]; for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #448: case MAT: case IFL: case SWI: { u64 len = tag == SWI ? lab : tag == IFL ? 2 : HVM.clen[lab]; for (u64 i = 0; i <= len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } #449: default: return wnf; #450: } } #451: // Primitives // ---------- #452: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #453: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #454: } #455: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #456: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #457: // Runtime Memory // -------------- #458: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; for (int i = 0; i < 65536; i++) { HVM.cari[i] = 0; HVM.clen[i] = 0; HVM.cadt[i] = 0; } } #459: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #460: State* hvm_get_state() { return &HVM; } #461: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } for (int i = 0; i < 65536; i++) { HVM.cari[i] = hvm->cari[i]; HVM.clen[i] = hvm->clen[i]; HVM.cadt[i] = hvm->cadt[i]; } } #462: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } #463: void hvm_set_cari(u64 cid, u16 arity) { HVM.cari[cid] = arity; } #464: void hvm_set_clen(u64 cid, u16 cases) { HVM.clen[cid] = cases; } void hvm_set_cadt(u64 cid, u16 adt) { HVM.cadt[cid] = adt; } ./Extract.hs #465: -- //./Type.hs// -- //./Inject.hs// #466: module HVML.Extract where #467: import Control.Monad (foldM) import Control.Monad.State import Data.Bits (shiftR) import Data.Char (chr, ord) import Data.IORef import Data.Word import Debug.Trace import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #468: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core #469: extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of #470: ERA -> do return Era #471: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #472: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod #473: APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg #474: SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #475: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #476: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) #477: DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #478: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let nam = mget (cidToCtr book) cid let ari = mget (cidToAri book) cid let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr nam fds #479: MAT -> do let loc = termLoc term let lab = termLab term let cid = lab `shiftR` 1 let len = fromIntegral $ mget (cidToLen book) cid val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do let ctr = mget (cidToCtr book) (cid + i) let ari = fromIntegral $ mget (cidToAri book) (cid + i) let fds = if ari == 0 then [] else ["$" ++ show (loc + 1 + j) | j <- [0..ari-1]] bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (ctr,fds,bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #480: IFL -> do let loc = termLoc term let lab = termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) cs0 <- extractCoreAt dupsRef reduceAt book (loc + 1) cs1 <- extractCoreAt dupsRef reduceAt book (loc + 2) return $ Mat val [] [(mget (cidToCtr book) lab, [], cs0), ("_", [], cs1)] #481: SWI -> do let loc = termLoc term let lab = termLab term let len = fromIntegral $ mget (cidToLen book) lab val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- foldM (\css i -> do bod <- extractCoreAt dupsRef reduceAt book (loc + 1 + i) return $ (show i, [], bod):css) [] [0..len-1] return $ Mat val [] (reverse css) #482: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #483: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #484: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #485: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 #486: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg #487: _ -> do return Era #488: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #489: -- Lifting Dups -- ------------ #490: liftDups :: Core -> (Core, Core -> Core) #491: liftDups (Var nam) = (Var nam, id) #492: liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) #493: liftDups Era = (Era, id) #494: liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) #495: liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) #496: liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) #497: liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) #498: liftDups (Ctr nam fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr nam fdsT, fdsD) #499: liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) #500: liftDups (U32 val) = (U32 val, id) #501: liftDups (Chr val) = (Chr val, id) #502: liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) #503: liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #504: liftDupsList :: [Core] -> ([Core], Core -> Core) #505: liftDupsList [] = ([], id) #506: liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #507: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) #508: liftDupsMov [] = ([], id) #509: liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #510: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) #511: liftDupsCss [] = ([], id) #512: liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #513: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #514: -- //./Type.hs// #515: module HVML.Inject where #516: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Bits (shiftL, (.|.)) import Data.Char (ord) import Data.List (foldr, take) import Data.Word import Debug.Trace import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #517: type InjectM a = StateT InjectState HVM a #518: data InjectState = InjectState { args :: MS.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #519: emptyState :: InjectState emptyState = InjectState MS.empty [] #520: injectCore :: Book -> Core -> Loc -> InjectM () #521: injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #522: injectCore _ (Var nam) loc = do argsMap <- gets args case MS.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = MS.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #523: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = MS.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #524: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #525: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #526: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #527: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = MS.insert dp0 (termNew _DP0_ lab dup) $ MS.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #528: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #529: injectCore book (Ctr nam fds) loc = do let ari = length fds let cid = mget (ctrToCid book) nam ctr <- lift $ allocNode (fromIntegral ari) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ cid ctr) #530: injectCore book tm@(Mat val mov css) loc = do typ <- return $ matType book tm mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + fromIntegral idx) let tag = case typ of { Switch -> _SWI_ ; Match -> _MAT_ ; IfLet -> _IFL_ } let lab = case typ of { Switch -> fromIntegral $ length css ; _ -> matFirstCid book tm } trm <- return $ termNew tag lab mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #531: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #532: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #533: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #534: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = MS.fromList argList }) foldM (\m (name, loc) -> do case MS.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ MS.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

7048bb6b909ac681ef00dc0306aea811ee320767

force & args to be strict

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #19: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #20: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #21: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #22: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #23: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #24: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #25: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #26: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #27: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #28: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #29: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #30: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #32: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #33: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #44: data SQ a = SQ [a] [a] #45: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #46: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #47: -- Flattener -- --------- #48: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #49: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #50: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #51: flatten :: Collapse a -> [a] flatten = flattenBFS #52: -- Flat Collapser -- -------------- #53: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #54: -- //./Type.hs// #55: module HVML.Show where #56: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #57: -- Core Stringification -- -------------------- #58: showCore :: Core -> String showCore = coreToString . prettyRename #59: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #60: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #61: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #62: -- Runtime Stringification -- ----------------------- #63: tagToString :: Tag -> String tagToString t = show (tagT t) #64: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #65: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #66: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #67: -- Pretty Renaming -- --------------- #68: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where go namesRef core = case core of Var name -> do name' <- genName namesRef name return $ Var name' Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' Ctr cid args -> do args' <- mapM (go namesRef) args return $ Ctr cid args' Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' other -> return other #69: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #70: -- Pretty Printers -- --------------- #71: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #72: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #73: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #74: -- Dumping -- ------- #75: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #76: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #77: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #78: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #79: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #80: -- //./Type.hs// #81: module HVML.Parse where #82: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #83: -- Core Parsers -- ------------ #84: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #85: type ParserM = Parsec String ParserState #86: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #87: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #88: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #89: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #90: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #91: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #92: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #93: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #94: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #95: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #96: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #97: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #100: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #101: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #102: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #103: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #104: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #105: -- Helper Parsers -- -------------- #106: consume :: String -> ParserM String consume str = skip >> string str #107: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #108: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #109: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #110: -- Adjusting -- --------- #111: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #112: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #113: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #114: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Reduce.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) -- import Control.Parallel import GHC.Conc import Data.FileEmbed import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS import Data.Time.Clock #166: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #195: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag #216: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #217: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #219: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #220: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #249: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #250: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #251: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #252: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #253: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #254: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #255: -- Constants -- --------- #256: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #257: _DP0_ :: Tag _DP0_ = 0x00 #258: _DP1_ :: Tag _DP1_ = 0x01 #259: _VAR_ :: Tag _VAR_ = 0x02 #260: _SUB_ :: Tag _SUB_ = 0x03 #261: _REF_ :: Tag _REF_ = 0x04 #262: _LET_ :: Tag _LET_ = 0x05 #263: _APP_ :: Tag _APP_ = 0x06 #264: _MAT_ :: Tag _MAT_ = 0x08 #265: _OPX_ :: Tag _OPX_ = 0x09 #266: _OPY_ :: Tag _OPY_ = 0x0A #267: _ERA_ :: Tag _ERA_ = 0x0B #268: _LAM_ :: Tag _LAM_ = 0x0C #269: _SUP_ :: Tag _SUP_ = 0x0D #270: _CTR_ :: Tag _CTR_ = 0x0F #271: _W32_ :: Tag _W32_ = 0x10 #272: _CHR_ :: Tag _CHR_ = 0x11 #273: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #274: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #275: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #276: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #277: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #278: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #279: -- Utils -- ----- #280: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #281: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #282: //./Type.hs// #283: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #284: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #285: typedef _Atomic(Term) ATerm; #286: // Runtime Types // ------------- #287: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #288: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #289: // Constants // --------- #290: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #291: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #292: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #293: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #294: #define VOID 0x00000000000000 #295: // Heap // ---- #296: Loc get_len() { return *HVM.size; } #297: u64 get_itr() { return *HVM.itrs; } #298: u64 fresh() { return (*HVM.frsh)++; } #299: void set_len(Loc value) { *HVM.size = value; } #300: void set_itr(Loc value) { *HVM.itrs = value; } #301: // Terms // ------ #302: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #303: Tag term_tag(Term x) { return x & 0x7F; } #304: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #305: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #306: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #307: Term term_set_bit(Term term) { return term | (1ULL << 7); } #308: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #309: } #310: // u12v2 // ----- #311: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #312: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #313: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #314: // Atomics // ------- #315: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #316: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #317: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #318: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #319: Term take(Loc loc) { return swap(loc, VOID); } #320: // Allocation // ---------- #321: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #322: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #323: // Stringification // --------------- #324: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #325: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #326: void print_term_ln(Term term) { print_term(term); printf("\n"); } #327: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #328: // Evaluation // ---------- #329: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #330: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #336: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #337: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #338: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #339: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #340: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #341: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #342: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #343: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #344: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #345: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #346: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #347: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #348: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #349: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #350: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #351: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #352: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #353: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #354: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #355: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #356: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #357: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #358: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #359: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #360: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #361: // Primitives // ---------- #362: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #363: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #364: } #365: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #366: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #367: // Runtime Memory // -------------- #368: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #369: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #370: State* hvm_get_state() { return &HVM; } #371: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #372: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #373: -- //./Type.hs// #374: module HVML.Extract where #375: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #376: import Debug.Trace #377: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #378: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #379: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #380: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #381: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #382: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #383: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #384: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #385: -- Lifting Dups -- ------------ #386: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #387: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #388: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #389: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #390: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #391: -- //./Type.hs// #392: module HVML.Inject where #393: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #394: type InjectM a = StateT InjectState HVM a #395: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #396: emptyState :: InjectState emptyState = InjectState Map.empty [] #397: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #398: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #399: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #400: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #401: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #402: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #403: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #404: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #405: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #406: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #407: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #408: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #409: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #410: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #19: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #20: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #21: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #22: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #23: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #24: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #25: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #26: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #27: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #28: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #29: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #30: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #32: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #33: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #44: data SQ a = SQ [a] [a] #45: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #46: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #47: -- Flattener -- --------- #48: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #49: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #50: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #51: flatten :: Collapse a -> [a] flatten = flattenBFS #52: -- Flat Collapser -- -------------- #53: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #54: -- //./Type.hs// #55: module HVML.Show where #56: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #57: -- Core Stringification -- -------------------- #58: showCore :: Core -> String showCore = coreToString . prettyRename #59: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #60: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #61: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #62: -- Runtime Stringification -- ----------------------- #63: tagToString :: Tag -> String tagToString t = show (tagT t) #64: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #65: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #66: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #67: -- Pretty Renaming -- --------------- #68: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where go namesRef core = case core of Var name -> do name' <- genName namesRef name return $ Var name' Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' Ctr cid args -> do args' <- mapM (go namesRef) args return $ Ctr cid args' Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' other -> return other #69: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #70: -- Pretty Printers -- --------------- #71: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #72: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #73: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #74: -- Dumping -- ------- #75: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #76: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #77: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #78: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #79: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #80: -- //./Type.hs// #81: module HVML.Parse where #82: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #83: -- Core Parsers -- ------------ #84: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #85: type ParserM = Parsec String ParserState #86: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #87: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #88: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #89: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #90: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #91: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #92: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #93: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #94: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #95: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #96: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #97: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" bang <- option False $ do try $ do consume "!" return True arg <- parseName let strict = bang || head arg == '&' return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #100: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #101: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #102: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #103: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #104: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #105: -- Helper Parsers -- -------------- #106: consume :: String -> ParserM String consume str = skip >> string str #107: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #108: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #109: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #110: -- Adjusting -- --------- #111: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #112: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #113: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #114: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Reduce.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) -- import Control.Parallel import GHC.Conc import Data.FileEmbed import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS import Data.Time.Clock #166: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #195: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag #216: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #217: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #219: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #220: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #249: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #250: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #251: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #252: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #253: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #254: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #255: -- Constants -- --------- #256: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #257: _DP0_ :: Tag _DP0_ = 0x00 #258: _DP1_ :: Tag _DP1_ = 0x01 #259: _VAR_ :: Tag _VAR_ = 0x02 #260: _SUB_ :: Tag _SUB_ = 0x03 #261: _REF_ :: Tag _REF_ = 0x04 #262: _LET_ :: Tag _LET_ = 0x05 #263: _APP_ :: Tag _APP_ = 0x06 #264: _MAT_ :: Tag _MAT_ = 0x08 #265: _OPX_ :: Tag _OPX_ = 0x09 #266: _OPY_ :: Tag _OPY_ = 0x0A #267: _ERA_ :: Tag _ERA_ = 0x0B #268: _LAM_ :: Tag _LAM_ = 0x0C #269: _SUP_ :: Tag _SUP_ = 0x0D #270: _CTR_ :: Tag _CTR_ = 0x0F #271: _W32_ :: Tag _W32_ = 0x10 #272: _CHR_ :: Tag _CHR_ = 0x11 #273: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #274: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #275: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #276: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #277: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #278: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #279: -- Utils -- ----- #280: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #281: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #282: //./Type.hs// #283: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #284: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #285: typedef _Atomic(Term) ATerm; #286: // Runtime Types // ------------- #287: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #288: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #289: // Constants // --------- #290: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #291: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #292: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #293: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #294: #define VOID 0x00000000000000 #295: // Heap // ---- #296: Loc get_len() { return *HVM.size; } #297: u64 get_itr() { return *HVM.itrs; } #298: u64 fresh() { return (*HVM.frsh)++; } #299: void set_len(Loc value) { *HVM.size = value; } #300: void set_itr(Loc value) { *HVM.itrs = value; } #301: // Terms // ------ #302: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #303: Tag term_tag(Term x) { return x & 0x7F; } #304: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #305: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #306: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #307: Term term_set_bit(Term term) { return term | (1ULL << 7); } #308: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #309: } #310: // u12v2 // ----- #311: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #312: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #313: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #314: // Atomics // ------- #315: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #316: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #317: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #318: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #319: Term take(Loc loc) { return swap(loc, VOID); } #320: // Allocation // ---------- #321: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #322: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #323: // Stringification // --------------- #324: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #325: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #326: void print_term_ln(Term term) { print_term(term); printf("\n"); } #327: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #328: // Evaluation // ---------- #329: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #330: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #336: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #337: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #338: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #339: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #340: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #341: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #342: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #343: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #344: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #345: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #346: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #347: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #348: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #349: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #350: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #351: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #352: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #353: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #354: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #355: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #356: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #357: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #358: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #359: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #360: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #361: // Primitives // ---------- #362: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #363: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #364: } #365: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #366: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #367: // Runtime Memory // -------------- #368: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #369: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #370: State* hvm_get_state() { return &HVM; } #371: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #372: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #373: -- //./Type.hs// #374: module HVML.Extract where #375: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #376: import Debug.Trace #377: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #378: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #379: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #380: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #381: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #382: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #383: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #384: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #385: -- Lifting Dups -- ------------ #386: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #387: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #388: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #389: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #390: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #391: -- //./Type.hs// #392: module HVML.Inject where #393: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #394: type InjectM a = StateT InjectState HVM a #395: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #396: emptyState :: InjectState emptyState = InjectState Map.empty [] #397: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #398: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #399: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #400: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #401: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #402: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #403: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #404: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #405: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #406: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #407: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #408: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #409: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #410: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

1d93eed51c5c6be5229ed2da5ff19be979b6389e

single-port lambdas! +20% MIPS on higher order tests. also moved renaming logic from extract/collapse to Show.hs

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: -- type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: -- collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core -- collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do -- term <- reduceAt book host -- case tagT (termTag term) of -- ERA -> do -- return Era #20: -- LET -> do -- let loc = termLoc term -- let mode = modeT (termLab term) -- name <- genName namesRef (loc + 0) -- val0 <- collapseDupsAt state reduceAt book (loc + 1) -- bod0 <- collapseDupsAt state reduceAt book (loc + 2) -- return $ Let mode name val0 bod0 #21: -- LAM -> do -- let loc = termLoc term -- name <- genName namesRef (loc + 0) -- bod0 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Lam name bod0 #22: -- APP -> do -- let loc = termLoc term -- fun0 <- collapseDupsAt state reduceAt book (loc + 0) -- arg0 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ App fun0 arg0 #23: -- SUP -> do -- let loc = termLoc term -- let lab = termLab term -- case IM.lookup (fromIntegral lab) paths of -- Just (p:ps) -> do -- let newPaths = IM.insert (fromIntegral lab) ps paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) -- _ -> do -- tm00 <- collapseDupsAt state reduceAt book (loc + 0) -- tm11 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Sup lab tm00 tm11 #24: -- VAR -> do -- let loc = termLoc term -- sub <- got loc -- if termTag sub /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 0) -- else do -- name <- genName namesRef loc -- return $ Var name #25: -- DP0 -> do -- let loc = termLoc term -- let lab = termLab term -- sb0 <- got (loc+0) -- sb1 <- got (loc+1) -- if termTag sb1 /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 0) -- else do -- let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #26: -- DP1 -> do -- let loc = termLoc term -- let lab = termLab term -- sb0 <- got (loc+0) -- sb1 <- got (loc+1) -- if termTag sb1 /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 1) -- else do -- let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #27: -- CTR -> do -- let loc = termLoc term -- let lab = termLab term -- let cid = u12v2X lab -- let ari = u12v2Y lab -- let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] -- fds0 <- forM aux (collapseDupsAt state reduceAt book) -- return $ Ctr cid fds0 #28: -- MAT -> do -- let loc = termLoc term -- let len = u12v2X $ termLab term -- let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] -- val0 <- collapseDupsAt state reduceAt book (loc + 0) -- css0 <- forM aux $ \h -> do -- bod <- collapseDupsAt state reduceAt book h -- return $ ("#", [], bod) -- TODO: recover constructor and fields -- return $ Mat val0 [] css0 #29: -- W32 -> do -- let val = termLoc term -- return $ U32 (fromIntegral val) #30: -- CHR -> do -- let val = termLoc term -- return $ Chr (chr (fromIntegral val)) #31: -- OPX -> do -- let loc = termLoc term -- let opr = toEnum (fromIntegral (termLab term)) -- nm00 <- collapseDupsAt state reduceAt book (loc + 0) -- nm10 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Op2 opr nm00 nm10 #32: -- OPY -> do -- let loc = termLoc term -- let opr = toEnum (fromIntegral (termLab term)) -- nm00 <- collapseDupsAt state reduceAt book (loc + 0) -- nm10 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Op2 opr nm00 nm10 #33: -- REF -> do -- let loc = termLoc term -- let lab = termLab term -- let fid = u12v2X lab -- let ari = u12v2Y lab -- arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] -- let name = MS.findWithDefault "?" fid (idToName book) -- return $ Ref name fid arg0 #34: -- tag -> do -- putStrLn ("unexpected-tag:" ++ show tag) -- exitFailure #35: -- genName :: IORef (MS.Map Loc String) -> Loc -> HVM String -- genName namesRef loc = do -- nameMap <- readIORef namesRef -- case MS.lookup loc nameMap of -- Just name -> return name -- Nothing -> do -- let newName = genNameFromIndex (MS.size nameMap) -- modifyIORef' namesRef (MS.insert loc newName) -- return newName #36: -- genNameFromIndex :: Int -> String -- genNameFromIndex n = go (n + 1) "" where -- go n ac | n == 0 = ac -- | otherwise = go q (chr (ord 'a' + r) : ac) -- where (q,r) = quotRem (n - 1) 26 #37: type CollapseDupsState = (IM.IntMap [Int]) #38: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #39: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #40: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #41: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #42: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #43: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #44: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #45: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #46: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #47: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #48: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #49: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #50: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #51: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #52: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #53: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #54: -- Sup Collapser -- ------------- #55: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #56: -- Tree Collapser -- -------------- #57: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #58: -- Priority Queue -- -------------- #59: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #60: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #61: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #62: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #63: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #64: data SQ a = SQ [a] [a] #65: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #66: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #67: -- Flattener -- --------- #68: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #69: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #70: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #71: flatten :: Collapse a -> [a] flatten = flattenBFS #72: -- Flat Collapser -- -------------- #73: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #74: -- //./Type.hs// #75: module HVML.Show where #76: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #77: -- Core Stringification -- -------------------- #78: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #79: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #80: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #81: -- Runtime Stringification -- ----------------------- #82: tagToString :: Tag -> String tagToString t = show (tagT t) #83: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #84: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #85: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #86: -- Pretty Printers -- --------------- #87: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #88: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #89: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #90: -- Dumping -- ------- #91: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #92: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #93: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #94: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #95: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #96: -- //./Type.hs// #97: module HVML.Parse where #98: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #99: -- Core Parsers -- ------------ #100: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #101: type ParserM = Parsec String ParserState #102: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #103: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #104: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #105: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #106: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #107: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #108: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #109: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #110: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #111: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #112: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #113: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #114: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #115: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #116: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #117: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #118: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #119: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #120: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #121: -- Helper Parsers -- -------------- #122: consume :: String -> ParserM String consume str = skip >> string str #123: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #124: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #125: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #126: -- Adjusting -- --------- #127: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #128: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #129: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #130: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #131: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #132: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #133: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #134: -- Errors -- ------ #135: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #136: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #137: -- //./Type.hs// #138: module HVML.Reduce where #139: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #140: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #141: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #142: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #143: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #144: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #145: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #146: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #147: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #148: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #149: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #150: -- //./Type.hs// -- //./Reduce.hs// #151: module HVML.Compile where #152: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #153: import Debug.Trace #154: -- Compilation -- ----------- #155: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #156: type Compile = State CompileState #157: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #158: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #159: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #160: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #161: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #162: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #163: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #164: -- Full Compiler -- ------------- #165: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #166: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #167: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #168: -- Fast Compiler -- ------------- #169: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #170: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #171: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #172: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #173: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #174: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #175: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #176: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #177: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #178: -- Type.hs: -- //./Type.hs// #179: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #180: module Main where #181: import Control.Monad (when, forM_) -- import Control.Parallel import GHC.Conc import Data.FileEmbed import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS import Data.Time.Clock #182: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #183: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #184: -- Main -- ---- #185: data RunMode = Normalize | Collapse | Search deriving Eq #186: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #187: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #188: -- CLI Commands -- ------------ #189: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #190: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #191: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #192: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #193: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #194: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #195: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #196: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #197: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term #198: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #199: when (mode /= Normalize) $ do putStrLn "" #200: -- Prints total time end <- getCPUTime #201: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #202: -- Finalize hvmFree return $ Right () #203: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #204: module HVML.Type where #205: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #206: -- Core Types -- ---------- #207: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #208: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #209: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #210: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #211: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #212: -- Runtime Types -- ------------- #213: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #214: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #215: type HVM = IO #216: type ReduceAt = Book -> Loc -> HVM Term #217: -- C Functions -- ----------- #218: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #219: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #220: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #221: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #222: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #223: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #224: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #225: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #226: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #227: foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag #228: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #229: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #230: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #231: foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag #232: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #233: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #234: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #235: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #236: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #258: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #259: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #260: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #261: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #262: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #263: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #264: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #265: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #266: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #267: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #268: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #269: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #270: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #271: -- Constants -- --------- #272: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #273: _DP0_ :: Tag _DP0_ = 0x00 #274: _DP1_ :: Tag _DP1_ = 0x01 #275: _VAR_ :: Tag _VAR_ = 0x02 #276: _SUB_ :: Tag _SUB_ = 0x03 #277: _REF_ :: Tag _REF_ = 0x04 #278: _LET_ :: Tag _LET_ = 0x05 #279: _APP_ :: Tag _APP_ = 0x06 #280: _MAT_ :: Tag _MAT_ = 0x08 #281: _OPX_ :: Tag _OPX_ = 0x09 #282: _OPY_ :: Tag _OPY_ = 0x0A #283: _ERA_ :: Tag _ERA_ = 0x0B #284: _LAM_ :: Tag _LAM_ = 0x0C #285: _SUP_ :: Tag _SUP_ = 0x0D #286: _CTR_ :: Tag _CTR_ = 0x0F #287: _W32_ :: Tag _W32_ = 0x10 #288: _CHR_ :: Tag _CHR_ = 0x11 #289: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #290: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #291: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #292: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #293: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #294: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #295: -- Utils -- ----- #296: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #297: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #298: //./Type.hs// #299: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #300: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #301: typedef _Atomic(Term) ATerm; #302: // Runtime Types // ------------- #303: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #304: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #305: // Constants // --------- #306: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #307: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #308: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #309: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #310: #define VOID 0x00000000000000 #311: // Heap // ---- #312: Loc get_len() { return *HVM.size; } #313: u64 get_itr() { return *HVM.itrs; } #314: u64 fresh() { return (*HVM.frsh)++; } #315: void set_len(Loc value) { *HVM.size = value; } #316: void set_itr(Loc value) { *HVM.itrs = value; } #317: // Terms // ------ #318: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #319: Tag term_tag(Term x) { return x & 0x7F; } #320: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #321: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #322: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #323: Term term_set_bit(Term term) { return term | (1ULL << 7); } #324: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #325: } #326: // u12v2 // ----- #327: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #328: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #329: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #330: // Atomics // ------- #331: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #332: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #333: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #334: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #335: Term take(Loc loc) { return swap(loc, VOID); } #336: // Allocation // ---------- #337: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #338: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #339: // Stringification // --------------- #340: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #341: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #342: void print_term_ln(Term term) { print_term(term); printf("\n"); } #343: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #344: // Evaluation // ---------- #345: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #346: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #347: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #348: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #349: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #350: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #351: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #352: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #353: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #354: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #355: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #356: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #357: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return got(dup_loc + dup_num); } #358: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return got(dup_loc + dup_num); } #359: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #360: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #361: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #362: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #363: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #364: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #365: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #366: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #367: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #368: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #369: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #370: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #371: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #372: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #373: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #374: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #375: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #376: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #377: // Primitives // ---------- #378: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #379: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #380: } #381: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #382: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #383: // Runtime Memory // -------------- #384: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #385: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #386: State* hvm_get_state() { return &HVM; } #387: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #388: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #389: -- //./Type.hs// #390: module HVML.Extract where #391: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #392: import Debug.Trace #393: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #394: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #395: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #396: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #397: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Let mode name val bod #398: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 0) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #399: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- genName state loc return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt state reduceAt book (loc + 0) #400: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #401: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #402: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #403: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #404: -- Lifting Dups -- ------------ #405: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #406: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #407: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #408: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #409: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #410: -- //./Type.hs// #411: module HVML.Inject where #412: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #413: type InjectM a = StateT InjectState HVM a #414: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #415: emptyState :: InjectState emptyState = InjectState Map.empty [] #416: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #417: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #418: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #419: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #420: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #421: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #422: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #423: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #424: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #425: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #426: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #427: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #428: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #429: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import GHC.Conc import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: -- type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: -- collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core -- collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do -- term <- reduceAt book host -- case tagT (termTag term) of -- ERA -> do -- return Era #20: -- LET -> do -- let loc = termLoc term -- let mode = modeT (termLab term) -- name <- genName namesRef (loc + 0) -- val0 <- collapseDupsAt state reduceAt book (loc + 1) -- bod0 <- collapseDupsAt state reduceAt book (loc + 2) -- return $ Let mode name val0 bod0 #21: -- LAM -> do -- let loc = termLoc term -- name <- genName namesRef (loc + 0) -- bod0 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Lam name bod0 #22: -- APP -> do -- let loc = termLoc term -- fun0 <- collapseDupsAt state reduceAt book (loc + 0) -- arg0 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ App fun0 arg0 #23: -- SUP -> do -- let loc = termLoc term -- let lab = termLab term -- case IM.lookup (fromIntegral lab) paths of -- Just (p:ps) -> do -- let newPaths = IM.insert (fromIntegral lab) ps paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) -- _ -> do -- tm00 <- collapseDupsAt state reduceAt book (loc + 0) -- tm11 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Sup lab tm00 tm11 #24: -- VAR -> do -- let loc = termLoc term -- sub <- got loc -- if termTag sub /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 0) -- else do -- name <- genName namesRef loc -- return $ Var name #25: -- DP0 -> do -- let loc = termLoc term -- let lab = termLab term -- sb0 <- got (loc+0) -- sb1 <- got (loc+1) -- if termTag sb1 /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 0) -- else do -- let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #26: -- DP1 -> do -- let loc = termLoc term -- let lab = termLab term -- sb0 <- got (loc+0) -- sb1 <- got (loc+1) -- if termTag sb1 /= _SUB_ -- then do -- collapseDupsAt state reduceAt book (loc + 1) -- else do -- let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths -- collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #27: -- CTR -> do -- let loc = termLoc term -- let lab = termLab term -- let cid = u12v2X lab -- let ari = u12v2Y lab -- let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] -- fds0 <- forM aux (collapseDupsAt state reduceAt book) -- return $ Ctr cid fds0 #28: -- MAT -> do -- let loc = termLoc term -- let len = u12v2X $ termLab term -- let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] -- val0 <- collapseDupsAt state reduceAt book (loc + 0) -- css0 <- forM aux $ \h -> do -- bod <- collapseDupsAt state reduceAt book h -- return $ ("#", [], bod) -- TODO: recover constructor and fields -- return $ Mat val0 [] css0 #29: -- W32 -> do -- let val = termLoc term -- return $ U32 (fromIntegral val) #30: -- CHR -> do -- let val = termLoc term -- return $ Chr (chr (fromIntegral val)) #31: -- OPX -> do -- let loc = termLoc term -- let opr = toEnum (fromIntegral (termLab term)) -- nm00 <- collapseDupsAt state reduceAt book (loc + 0) -- nm10 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Op2 opr nm00 nm10 #32: -- OPY -> do -- let loc = termLoc term -- let opr = toEnum (fromIntegral (termLab term)) -- nm00 <- collapseDupsAt state reduceAt book (loc + 0) -- nm10 <- collapseDupsAt state reduceAt book (loc + 1) -- return $ Op2 opr nm00 nm10 #33: -- REF -> do -- let loc = termLoc term -- let lab = termLab term -- let fid = u12v2X lab -- let ari = u12v2Y lab -- arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] -- let name = MS.findWithDefault "?" fid (idToName book) -- return $ Ref name fid arg0 #34: -- tag -> do -- putStrLn ("unexpected-tag:" ++ show tag) -- exitFailure #35: -- genName :: IORef (MS.Map Loc String) -> Loc -> HVM String -- genName namesRef loc = do -- nameMap <- readIORef namesRef -- case MS.lookup loc nameMap of -- Just name -> return name -- Nothing -> do -- let newName = genNameFromIndex (MS.size nameMap) -- modifyIORef' namesRef (MS.insert loc newName) -- return newName #36: -- genNameFromIndex :: Int -> String -- genNameFromIndex n = go (n + 1) "" where -- go n ac | n == 0 = ac -- | otherwise = go q (chr (ord 'a' + r) : ac) -- where (q,r) = quotRem (n - 1) 26 #37: collapseDupsAt :: IM.IntMap [Int] -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #38: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #39: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 0) return $ Lam name bod0 #40: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #41: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #42: VAR -> do let loc = termLoc term sub <- got loc if termGetBit sub /= 0 then do set (loc + 0) (termRemBit sub) collapseDupsAt state reduceAt book (loc + 0) else do name <- return $ "$" ++ show loc return $ Var name #43: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) if termGetBit sb0 /= 0 then do set (loc + 0) (termRemBit sb0) collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #44: DP1 -> do let loc = termLoc term let lab = termLab term sb1 <- got (loc+1) if termGetBit sb1 /= 0 then do set (loc + 1) (termRemBit sb1) collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths) reduceAt book (loc + 0) #45: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #46: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #47: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #48: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #49: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #50: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #51: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #52: tag -> do putStrLn ("unexpected-tag:" ++ show tag) return $ Var "?" -- exitFailure #53: -- Sup Collapser -- ------------- #54: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #55: -- Tree Collapser -- -------------- #56: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do -- namesRef <- newIORef MS.empty let state = (IM.empty) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #57: -- Priority Queue -- -------------- #58: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #59: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #60: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #61: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #62: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #63: data SQ a = SQ [a] [a] #64: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #65: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #66: -- Flattener -- --------- #67: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #68: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #69: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #70: flatten :: Collapse a -> [a] flatten = flattenBFS #71: -- Flat Collapser -- -------------- #72: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #73: -- //./Type.hs// #74: module HVML.Show where #75: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (chr, ord) import Data.Char (intToDigit) import Data.IORef import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) import System.IO.Unsafe (unsafePerformIO) import qualified Data.Map.Strict as MS #76: -- Core Stringification -- -------------------- #77: showCore :: Core -> String showCore = coreToString . prettyRename #78: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #79: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #80: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #81: -- Runtime Stringification -- ----------------------- #82: tagToString :: Tag -> String tagToString t = show (tagT t) #83: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #84: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #85: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #86: -- Pretty Renaming -- --------------- #87: prettyRename :: Core -> Core prettyRename core = unsafePerformIO $ do namesRef <- newIORef MS.empty go namesRef core where go namesRef core = case core of Var name -> do name' <- genName namesRef name return $ Var name' Lam name body -> do name' <- genName namesRef name body' <- go namesRef body return $ Lam name' body' Let mode name val body -> do name' <- genName namesRef name val' <- go namesRef val body' <- go namesRef body return $ Let mode name' val' body' App fun arg -> do fun' <- go namesRef fun arg' <- go namesRef arg return $ App fun' arg' Sup lab x y -> do x' <- go namesRef x y' <- go namesRef y return $ Sup lab x' y' Dup lab x y val body -> do x' <- genName namesRef x y' <- genName namesRef y val' <- go namesRef val body' <- go namesRef body return $ Dup lab x' y' val' body' Ctr cid args -> do args' <- mapM (go namesRef) args return $ Ctr cid args' Mat val mov css -> do val' <- go namesRef val mov' <- mapM (\(k,v) -> do v' <- go namesRef v; return (k,v')) mov css' <- mapM (\(c,vs,t) -> do t' <- go namesRef t; return (c,vs,t')) css return $ Mat val' mov' css' Op2 op x y -> do x' <- go namesRef x y' <- go namesRef y return $ Op2 op x' y' Ref name fid args -> do args' <- mapM (go namesRef) args return $ Ref name fid args' other -> return other #88: genName namesRef name = do nameMap <- readIORef namesRef case MS.lookup name nameMap of Just name' -> return name' Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert name newName) return newName genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #89: -- Pretty Printers -- --------------- #90: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #91: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #92: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #93: -- Dumping -- ------- #94: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #95: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #96: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #97: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #98: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #99: -- //./Type.hs// #100: module HVML.Parse where #101: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #102: -- Core Parsers -- ------------ #103: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #104: type ParserM = Parsec String ParserState #105: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #106: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #107: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #108: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #109: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #110: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #111: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #112: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #113: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #114: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #115: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #116: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #117: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #118: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #119: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #120: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #121: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #122: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #123: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #124: -- Helper Parsers -- -------------- #125: consume :: String -> ParserM String consume str = skip >> string str #126: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #127: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #128: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #129: -- Adjusting -- --------- #130: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #131: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #132: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #133: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #134: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #135: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #136: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #137: -- Errors -- ------ #138: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #139: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #140: -- //./Type.hs// #141: module HVML.Reduce where #142: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #143: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 0) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 0) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term DP0 -> do sb0 <- got (loc + 0) if termGetBit sb0 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb0) reduceAt debug book host DP1 -> do sb1 <- got (loc + 1) if termGetBit sb1 == 0 then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host (termRemBit sb1) reduceAt debug book host VAR -> do sub <- got (loc + 0) if termGetBit sub == 0 then return term else do set host (termRemBit sub) reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #144: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #145: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #146: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #147: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #148: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #149: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #150: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #151: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #152: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #153: -- //./Type.hs// -- //./Reduce.hs// #154: module HVML.Compile where #155: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #156: import Debug.Trace #157: -- Compilation -- ----------- #158: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #159: type Compile = State CompileState #160: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #161: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #162: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #163: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #164: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #165: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #166: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #167: -- Full Compiler -- ------------- #168: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #169: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #170: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(2);" -- emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 0") emit $ "set(" ++ letNam ++ " + 0, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(1);" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 0") emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #171: -- Fast Compiler -- ------------- #172: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #173: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #174: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #175: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #176: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #177: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #178: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 1 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" -- emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 0, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #179: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #180: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #181: -- Type.hs: -- //./Type.hs// #182: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #183: module Main where #184: import Control.Monad (when, forM_) -- import Control.Parallel import GHC.Conc import Data.FileEmbed import Data.Word import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS import Data.Time.Clock #185: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #186: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #187: -- Main -- ---- #188: data RunMode = Normalize | Collapse | Search deriving Eq #189: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #190: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #191: -- CLI Commands -- ------------ #192: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #193: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #194: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #195: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #196: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #197: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #198: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #199: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #200: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ showCore term #201: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ showCore (head vals) #202: when (mode /= Normalize) $ do putStrLn "" #203: -- Prints total time end <- getCPUTime #204: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #205: -- Finalize hvmFree return $ Right () #206: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #207: module HVML.Type where #208: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #209: -- Core Types -- ---------- #210: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #211: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #212: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #213: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #214: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #215: -- Runtime Types -- ------------- #216: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #217: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #218: type HVM = IO #219: type ReduceAt = Book -> Loc -> HVM Term #220: -- C Functions -- ----------- #221: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #222: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #223: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #224: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #225: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #226: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #227: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #228: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #229: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #230: foreign import ccall unsafe "Runtime.c term_get_bit" termGetBit :: Term -> Tag #231: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #232: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #233: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #234: foreign import ccall unsafe "Runtime.c term_rem_bit" termRemBit :: Term -> Tag #235: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #236: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #237: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #238: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #239: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #258: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #259: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #260: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #261: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #262: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #263: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #264: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #265: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #266: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #267: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #268: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #269: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #270: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #271: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #272: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #273: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #274: -- Constants -- --------- #275: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #276: _DP0_ :: Tag _DP0_ = 0x00 #277: _DP1_ :: Tag _DP1_ = 0x01 #278: _VAR_ :: Tag _VAR_ = 0x02 #279: _SUB_ :: Tag _SUB_ = 0x03 #280: _REF_ :: Tag _REF_ = 0x04 #281: _LET_ :: Tag _LET_ = 0x05 #282: _APP_ :: Tag _APP_ = 0x06 #283: _MAT_ :: Tag _MAT_ = 0x08 #284: _OPX_ :: Tag _OPX_ = 0x09 #285: _OPY_ :: Tag _OPY_ = 0x0A #286: _ERA_ :: Tag _ERA_ = 0x0B #287: _LAM_ :: Tag _LAM_ = 0x0C #288: _SUP_ :: Tag _SUP_ = 0x0D #289: _CTR_ :: Tag _CTR_ = 0x0F #290: _W32_ :: Tag _W32_ = 0x10 #291: _CHR_ :: Tag _CHR_ = 0x11 #292: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #293: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #294: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #295: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #296: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #297: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #298: -- Utils -- ----- #299: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #300: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #301: //./Type.hs// #302: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #303: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #304: typedef _Atomic(Term) ATerm; #305: // Runtime Types // ------------- #306: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #307: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #308: // Constants // --------- #309: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #310: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #311: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #312: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #313: #define VOID 0x00000000000000 #314: // Heap // ---- #315: Loc get_len() { return *HVM.size; } #316: u64 get_itr() { return *HVM.itrs; } #317: u64 fresh() { return (*HVM.frsh)++; } #318: void set_len(Loc value) { *HVM.size = value; } #319: void set_itr(Loc value) { *HVM.itrs = value; } #320: // Terms // ------ #321: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #322: Tag term_tag(Term x) { return x & 0x7F; } #323: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #324: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #325: Tag term_get_bit(Term x) { return (x >> 7) & 1; } #326: Term term_set_bit(Term term) { return term | (1ULL << 7); } #327: Term term_rem_bit(Term term) { return term & ~(1ULL << 7); #328: } #329: // u12v2 // ----- #330: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #331: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #332: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #333: // Atomics // ------- #334: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #335: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #336: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #337: void sub(Loc loc, Term term) { set(loc, term_set_bit(term)); } #338: Term take(Loc loc) { return swap(loc, VOID); } #339: // Allocation // ---------- #340: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #341: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #342: // Stringification // --------------- #343: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #344: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #345: void print_term_ln(Term term) { print_term(term); printf("\n"); } #346: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #347: // Evaluation // ---------- #348: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #349: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #350: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 1); sub(let_loc + 0, val); return bod; } #351: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #352: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 0); sub(lam_loc + 0, arg); return bod; } #353: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #354: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #355: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #356: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, era); sub(dup_loc + 1, era); return term_rem_bit(got(dup_loc + dup_num)); } #357: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 0); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(1); Loc lm1 = alloc_node(1); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); //set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(DP0, dup_lab, du0)); //set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 0, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); sub(dup_loc + 0, term_new(LAM, 0, lm0)); sub(dup_loc + 1, term_new(LAM, 0, lm1)); sub(lam_loc + 0, term_new(SUP, dup_lab, su0)); return term_rem_bit(got(dup_loc + dup_num)); } #358: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); sub(dup_loc + 0, tm0); sub(dup_loc + 1, tm1); return term_rem_bit(got(dup_loc + dup_num)); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); sub(dup_loc + 0, term_new(SUP, sup_lab, su0)); sub(dup_loc + 1, term_new(SUP, sup_lab, su1)); return term_rem_bit(got(dup_loc + dup_num)); } } #359: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); sub(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return term_rem_bit(got(dup_loc + dup_num)); } #360: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; sub(dup_loc + 0, w32); sub(dup_loc + 1, w32); return term_rem_bit(got(dup_loc + dup_num)); } #361: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } sub(dup_loc + 0, term_new(REF, ref_lab, ref0)); sub(dup_loc + 1, term_new(REF, ref_lab, ref1)); return term_rem_bit(got(dup_loc + dup_num)); } #362: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #363: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #364: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #365: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #366: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #367: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #368: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #369: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #370: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #371: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #372: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #373: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #374: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #375: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #376: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #377: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 0)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); if (term_get_bit(sb0) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb0); continue; } } case DP1: { Term sb1 = got(loc + 1); if (term_get_bit(sb1) == 0) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = term_rem_bit(sb1); continue; } } case VAR: { Term sub = got(loc); if (term_get_bit(sub) == 0) { break; } else { next = term_rem_bit(sub); continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #378: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #379: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 0); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #380: // Primitives // ---------- #381: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #382: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 0); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 0); sub(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); sub(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #383: } #384: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #385: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #386: // Runtime Memory // -------------- #387: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #388: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #389: State* hvm_get_state() { return &HVM; } #390: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #391: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #392: -- //./Type.hs// #393: module HVML.Extract where #394: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #395: import Debug.Trace #396: extractCoreAt :: IORef IS.IntSet -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt dupsRef reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #397: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- return $ "$" ++ show (loc + 0) val <- extractCoreAt dupsRef reduceAt book (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Let mode name val bod #398: LAM -> do let loc = termLoc term name <- return $ "$" ++ show (loc + 0) bod <- extractCoreAt dupsRef reduceAt book (loc + 0) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt dupsRef reduceAt book (loc + 0) arg <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) tm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #399: VAR -> do let loc = termLoc term sub <- got (loc + 0) if termGetBit sub == 0 then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do set (loc + 0) (termRemBit sub) extractCoreAt dupsRef reduceAt book (loc + 0) #400: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 0) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- return $ "$" ++ show (loc + 1) return $ Var name else do dp0 <- return $ "$" ++ show (loc + 0) dp1 <- return $ "$" ++ show (loc + 1) val <- extractCoreAt dupsRef reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #401: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt dupsRef reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #402: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt dupsRef reduceAt book (loc + 0) nm1 <- extractCoreAt dupsRef reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt dupsRef reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #403: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty core <- extractCoreAt dupsRef reduceAt book loc return core -- return $ doLiftDups core #404: -- Lifting Dups -- ------------ #405: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #406: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #407: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #408: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #409: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Inject.hs #410: -- //./Type.hs// #411: module HVML.Inject where #412: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #413: type InjectM a = StateT InjectState HVM a #414: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #415: emptyState :: InjectState emptyState = InjectState Map.empty [] #416: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #417: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #418: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 2 modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 0) injectCore book bod (let_node + 1) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #419: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 1 -- lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 0) lift $ set loc (termNew _LAM_ 0 lam) #420: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #421: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #422: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #423: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #424: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #425: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #426: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #427: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #428: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #429: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

4a54bc7e81663ccddd60275eb17cc5a109aa7ba6

fast compiled mode for if-let

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref "SUP" _SUP_F_ _ -> MS.singleton maxBound () Ref "DUP" _DUP_F_ _ -> MS.singleton maxBound () Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Typ _ typ -> collectLabels typ Ann val typ -> MS.union (collectLabels val) (collectLabels typ) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #116: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #117: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #118: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #119: -- Errors -- ------ #120: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #121: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #122: -- //./Type.hs// #123: module HVML.Reduce where #124: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #125: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #126: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #127: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #128: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #129: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #130: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #131: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #132: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #133: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #134: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #135: -- //./Type.hs// -- //./Reduce.hs// #136: module HVML.Compile where #137: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #138: import Debug.Trace #139: -- Compilation -- ----------- #140: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #141: type Compile = State CompileState #142: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #143: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #144: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #145: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #146: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #147: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #148: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #149: -- Full Compiler -- ------------- #150: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #151: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #152: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #153: -- Fast Compiler -- ------------- #154: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #155: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #156: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #157: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #158: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #159: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #160: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #161: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #162: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #163: -- Type.hs: -- //./Type.hs// #164: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #165: module Main where #166: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #167: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #168: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #169: -- Main -- ---- #170: data RunMode = Normalize | Collapse | Search deriving Eq #171: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #172: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #173: -- CLI Commands -- ------------ #174: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #175: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #176: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #177: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #178: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #179: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #180: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #181: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #182: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #183: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #184: when (mode /= Normalize) $ do putStrLn "" #185: -- Prints total time end <- getCPUTime #186: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #187: -- Finalize hvmFree return $ Right () #188: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #189: module HVML.Type where #190: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #191: -- Core Types -- ---------- #192: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #193: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #194: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #195: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #196: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #197: -- Runtime Types -- ------------- #198: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #199: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #200: type HVM = IO #201: type ReduceAt = Book -> Loc -> HVM Term #202: -- C Functions -- ----------- #203: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #204: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #205: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #206: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #207: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #210: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #211: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #213: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #214: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #215: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #216: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #217: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #219: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #220: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #258: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #259: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #260: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #261: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #262: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #263: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #264: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #265: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #266: -- Constants -- --------- #267: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #268: _DP0_ :: Tag _DP0_ = 0x00 #269: _DP1_ :: Tag _DP1_ = 0x01 #270: _VAR_ :: Tag _VAR_ = 0x02 #271: _SUB_ :: Tag _SUB_ = 0x03 #272: _REF_ :: Tag _REF_ = 0x04 #273: _LET_ :: Tag _LET_ = 0x05 #274: _APP_ :: Tag _APP_ = 0x06 #275: _ANN_ :: Tag _ANN_ = 0x07 #276: _MAT_ :: Tag _MAT_ = 0x08 #277: _OPX_ :: Tag _OPX_ = 0x09 #278: _OPY_ :: Tag _OPY_ = 0x0A #279: _ERA_ :: Tag _ERA_ = 0x0B #280: _LAM_ :: Tag _LAM_ = 0x0C #281: _SUP_ :: Tag _SUP_ = 0x0D #282: _TYP_ :: Tag _TYP_ = 0x0E #283: _CTR_ :: Tag _CTR_ = 0x0F #284: _W32_ :: Tag _W32_ = 0x10 #285: _CHR_ :: Tag _CHR_ = 0x11 #286: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #287: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #288: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #289: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #290: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #291: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #292: -- Utils -- ----- #293: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #294: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #295: //./Type.hs// #296: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #297: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #298: typedef _Atomic(Term) ATerm; #299: // Runtime Types // ------------- #300: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #301: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #302: // Constants // --------- #303: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #304: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #305: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #306: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #307: #define VOID 0x00000000000000 #308: // Heap // ---- #309: Loc get_len() { return *HVM.size; } #310: u64 get_itr() { return *HVM.itrs; } #311: u64 fresh() { return (*HVM.frsh)++; } #312: void set_len(Loc value) { *HVM.size = value; } #313: void set_itr(Loc value) { *HVM.itrs = value; } #314: // Terms // ------ #315: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #316: Tag term_tag(Term x) { return x & 0x7F; } #317: Tag term_bit(Term x) { return (x >> 7) & 1; } #318: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #319: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #320: Term term_set_bit(Term term) { return term | (1ULL << 7); } #321: // u12v2 // ----- #322: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #323: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #324: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #325: // Atomics // ------- #326: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #327: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #328: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #329: Term take(Loc loc) { return swap(loc, VOID); } #330: // Allocation // ---------- #331: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #332: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #333: // Stringification // --------------- #334: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #335: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #336: void print_term_ln(Term term) { print_term(term); printf("\n"); } #337: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #338: // Evaluation // ---------- #339: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} // TODO: implement this in an index-generic way. // that is, receive the index where the SUP is. // clone all other indexes with a DUP Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #340: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #341: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #342: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #343: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #344: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #345: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #346: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #347: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #348: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #349: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #350: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #351: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #352: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #353: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #354: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(REF, ref_lab, ref0)); set(dup_loc + 1, term_new(REF, ref_lab, ref1)); return got(dup_loc + dup_num); } #355: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #356: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #357: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #358: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #359: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #360: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #361: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #362: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #363: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #364: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #365: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #366: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #367: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #368: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #369: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #370: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #371: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #372: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #373: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #374: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #375: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #376: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #377: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #378: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #379: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #380: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #381: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #382: // Primitives // ---------- #383: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #384: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 1); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 1); set(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); set(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #385: } #386: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #387: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #388: // Runtime Memory // -------------- #389: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #390: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #391: State* hvm_get_state() { return &HVM; } #392: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #393: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #394: -- //./Type.hs// #395: module HVML.Extract where #396: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #397: import Debug.Trace #398: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #399: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #400: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #401: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #402: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #403: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #404: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #405: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #406: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #407: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #408: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #409: -- Lifting Dups -- ------------ #410: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #411: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #412: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #413: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #414: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #415: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #416: module HVML.Equal where #417: import Control.Monad (liftM2) import HVML.Type import HVML.Show #418: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #419: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #420: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #421: -- //./Type.hs// #422: module HVML.Inject where #423: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #424: type InjectM a = StateT InjectState HVM a #425: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #426: emptyState :: InjectState emptyState = InjectState Map.empty [] #427: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #428: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #429: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #430: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #431: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #432: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #433: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #434: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #435: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #436: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #437: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #438: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #439: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #440: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #441: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #442: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Typ _ typ -> collectLabels typ Ann val typ -> MS.union (collectLabels val) (collectLabels typ) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #116: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #117: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #118: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #119: -- Errors -- ------ #120: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #121: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #122: -- //./Type.hs// #123: module HVML.Reduce where #124: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #125: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #126: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #127: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #128: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #129: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #130: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #131: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #132: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #133: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #134: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #135: -- //./Type.hs// -- //./Reduce.hs// #136: module HVML.Compile where #137: import Control.Monad (forM_, forM, foldM, when) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #138: import Debug.Trace #139: -- Compilation -- ----------- #140: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #141: type Compile = State CompileState #142: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #143: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #144: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #145: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #146: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #147: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #148: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #149: -- Full Compiler -- ------------- #150: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #151: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #152: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #153: -- Fast Compiler -- ------------- #154: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == ERA) {" emit $ " return term_new(ERA, 0, 0);" emit $ "}" emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #155: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #156: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do if ifLetLab book term > 0 then do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "if (u12v2_x(term_lab(" ++ valNam ++ ")) == " ++ show (ifLetLab book term - 1) ++ ") {" tabInc let (ctr,fds,bod) = css !! 0 let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' tabDec emit $ "} else {" tabInc let (ctr,fds,bod) = css !! 1 when (length fds /= 1) $ do error "incorrect arity on if-let default case" fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = " ++ valNam ++ ";" bind (head fds) fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + 1 + length mov) reuse tabDec emit $ "}" tabDec emit $ "}" else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #157: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #158: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #159: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #160: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #161: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #162: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #163: -- Type.hs: -- //./Type.hs// #164: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #165: module Main where #166: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #167: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #168: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #169: -- Main -- ---- #170: data RunMode = Normalize | Collapse | Search deriving Eq #171: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #172: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #173: -- CLI Commands -- ------------ #174: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #175: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #176: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #177: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #178: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #179: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #180: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #181: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #182: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #183: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #184: when (mode /= Normalize) $ do putStrLn "" #185: -- Prints total time end <- getCPUTime #186: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #187: -- Finalize hvmFree return $ Right () #188: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #189: module HVML.Type where #190: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #191: -- Core Types -- ---------- #192: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #193: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #194: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #195: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #196: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #197: -- Runtime Types -- ------------- #198: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #199: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #200: type HVM = IO #201: type ReduceAt = Book -> Loc -> HVM Term #202: -- C Functions -- ----------- #203: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #204: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #205: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #206: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #207: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #210: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #211: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #213: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #214: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #215: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #216: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #217: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #219: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #220: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #258: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #259: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #260: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #261: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #262: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #263: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #264: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #265: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #266: -- Constants -- --------- #267: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #268: _DP0_ :: Tag _DP0_ = 0x00 #269: _DP1_ :: Tag _DP1_ = 0x01 #270: _VAR_ :: Tag _VAR_ = 0x02 #271: _SUB_ :: Tag _SUB_ = 0x03 #272: _REF_ :: Tag _REF_ = 0x04 #273: _LET_ :: Tag _LET_ = 0x05 #274: _APP_ :: Tag _APP_ = 0x06 #275: _ANN_ :: Tag _ANN_ = 0x07 #276: _MAT_ :: Tag _MAT_ = 0x08 #277: _OPX_ :: Tag _OPX_ = 0x09 #278: _OPY_ :: Tag _OPY_ = 0x0A #279: _ERA_ :: Tag _ERA_ = 0x0B #280: _LAM_ :: Tag _LAM_ = 0x0C #281: _SUP_ :: Tag _SUP_ = 0x0D #282: _TYP_ :: Tag _TYP_ = 0x0E #283: _CTR_ :: Tag _CTR_ = 0x0F #284: _W32_ :: Tag _W32_ = 0x10 #285: _CHR_ :: Tag _CHR_ = 0x11 #286: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #287: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #288: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #289: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #290: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #291: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #292: -- Utils -- ----- #293: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #294: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #295: //./Type.hs// #296: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #297: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #298: typedef _Atomic(Term) ATerm; #299: // Runtime Types // ------------- #300: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #301: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #302: // Constants // --------- #303: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #304: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #305: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #306: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #307: #define VOID 0x00000000000000 #308: // Heap // ---- #309: Loc get_len() { return *HVM.size; } #310: u64 get_itr() { return *HVM.itrs; } #311: u64 fresh() { return (*HVM.frsh)++; } #312: void set_len(Loc value) { *HVM.size = value; } #313: void set_itr(Loc value) { *HVM.itrs = value; } #314: // Terms // ------ #315: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #316: Tag term_tag(Term x) { return x & 0x7F; } #317: Tag term_bit(Term x) { return (x >> 7) & 1; } #318: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #319: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #320: Term term_set_bit(Term term) { return term | (1ULL << 7); } #321: // u12v2 // ----- #322: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #323: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #324: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #325: // Atomics // ------- #326: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #327: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #328: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #329: Term take(Loc loc) { return swap(loc, VOID); } #330: // Allocation // ---------- #331: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #332: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #333: // Stringification // --------------- #334: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #335: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #336: void print_term_ln(Term term) { print_term(term); printf("\n"); } #337: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #338: // Evaluation // ---------- #339: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP-COPY (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} // TODO: implement this in an index-generic way. // that is, receive the index where the SUP is. // clone all other indexes with a DUP Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #340: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #341: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #342: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #343: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #344: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #345: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #346: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #347: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #348: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #349: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #350: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #351: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #352: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #353: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #354: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF-COPY (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(REF, ref_lab, ref0)); set(dup_loc + 1, term_new(REF, ref_lab, ref1)); return got(dup_loc + dup_num); } #355: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #356: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #357: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #358: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #359: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #360: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #361: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #362: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #363: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #364: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #365: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #366: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #367: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #368: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #369: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #370: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #371: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #372: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #373: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #374: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #375: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #376: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #377: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #378: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #379: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #380: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #381: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #382: // Primitives // ---------- #383: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #384: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 1); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 1); set(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); set(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #385: } #386: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #387: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #388: // Runtime Memory // -------------- #389: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #390: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #391: State* hvm_get_state() { return &HVM; } #392: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #393: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #394: -- //./Type.hs// #395: module HVML.Extract where #396: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #397: import Debug.Trace #398: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #399: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #400: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #401: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #402: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #403: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #404: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #405: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #406: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #407: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #408: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #409: -- Lifting Dups -- ------------ #410: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #411: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #412: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #413: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #414: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #415: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #416: module HVML.Equal where #417: import Control.Monad (liftM2) import HVML.Type import HVML.Show #418: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #419: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #420: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #421: -- //./Type.hs// #422: module HVML.Inject where #423: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #424: type InjectM a = StateT InjectState HVM a #425: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #426: emptyState :: InjectState emptyState = InjectState Map.empty [] #427: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #428: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #429: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #430: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #431: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #432: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #433: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #434: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #435: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #436: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #437: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #438: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #439: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #440: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #441: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #442: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

ed2adeccc73f9ad570f6c6bc33f6a5578f7039df

fast DUP-REF and REF-SUP interactions (copy mode) now function declarations can be tagged with a '!', which will make them eligible for the copy interactions: @foo(&L{ax ay} b c ...) ----------------------- REF-SUP-COPY (when @L not in @foo) ! &L{bx by} = b ! &L{cx cy} = b ... &L{@foo(ax bx cx ...) @foo(ay by cy ...)} ! &L{x y} = @foo(a b c ...) --------------------------- DUP-REF-COPY (when &L not in @foo) ! &L{a0 a1} = a ! &L{b0 b1} = b ! &L{c0 c1} = c ... x <- @foo(a0 b0 c0 ...) y <- @foo(a1 b1 c1 ...) these rules will allow REF nodes to be cloned and collapsed before dereferencing their bodies, which can be useful in some cases. it can be used to ensure the hot path of compiled functions is hit, even when the argument is a superposition (because it would turn '@foo(&{#A #B})' into '&0{@foo(#A) @foo(#B)}'. it is also useful when passing higher order fns. for example `&0{f0 f1} = @foo` would copy just a reference to '@foo', instead of expanding and cloning its body, so that, when it is actually called, it might also activate the hot paths. that said, this interaction breaks optimality, so, for example, a function won't get "auto memoized" when copy mode is enabled for it, and interaction count can grow in many similar situations; in some cases, exponentially so. overall this is good to give the programmer a control mechanism to ensure hot paths on the C compiler are hit, but it should be used with caution as to not lose optimality when it is desirable.

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ([(Bool, String)], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, (args, core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ([(Bool,String)], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([(Bool,String)], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ([(Bool,String)], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (args, core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms Nothing -> return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Inject.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" -- TODO: if it is a strict argument, use "reduce_at" instead of "got" if fst arg then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind (snd arg) argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #166: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: type Func = ([(Bool,String)], Core) #195: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #216: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #217: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #219: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #258: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #259: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #260: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #261: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #262: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #263: -- Constants -- --------- #264: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #265: _DP0_ :: Tag _DP0_ = 0x00 #266: _DP1_ :: Tag _DP1_ = 0x01 #267: _VAR_ :: Tag _VAR_ = 0x02 #268: _SUB_ :: Tag _SUB_ = 0x03 #269: _REF_ :: Tag _REF_ = 0x04 #270: _LET_ :: Tag _LET_ = 0x05 #271: _APP_ :: Tag _APP_ = 0x06 #272: _ANN_ :: Tag _ANN_ = 0x07 #273: _MAT_ :: Tag _MAT_ = 0x08 #274: _OPX_ :: Tag _OPX_ = 0x09 #275: _OPY_ :: Tag _OPY_ = 0x0A #276: _ERA_ :: Tag _ERA_ = 0x0B #277: _LAM_ :: Tag _LAM_ = 0x0C #278: _SUP_ :: Tag _SUP_ = 0x0D #279: _TYP_ :: Tag _TYP_ = 0x0E #280: _CTR_ :: Tag _CTR_ = 0x0F #281: _W32_ :: Tag _W32_ = 0x10 #282: _CHR_ :: Tag _CHR_ = 0x11 #283: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #284: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #285: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 #286: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #287: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #288: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #289: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #290: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #291: //./Type.hs// #292: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #293: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #294: typedef _Atomic(Term) ATerm; #295: // Runtime Types // ------------- #296: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #297: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #298: // Constants // --------- #299: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #300: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #301: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #302: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #303: #define VOID 0x00000000000000 #304: // Heap // ---- #305: Loc get_len() { return *HVM.size; } #306: u64 get_itr() { return *HVM.itrs; } #307: u64 fresh() { return (*HVM.frsh)++; } #308: void set_len(Loc value) { *HVM.size = value; } #309: void set_itr(Loc value) { *HVM.itrs = value; } #310: // Terms // ------ #311: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #312: Tag term_tag(Term x) { return x & 0x7F; } #313: Tag term_bit(Term x) { return (x >> 7) & 1; } #314: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #315: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #316: Term term_set_bit(Term term) { return term | (1ULL << 7); } #317: // u12v2 // ----- #318: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #319: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #320: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #321: // Atomics // ------- #322: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #323: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #324: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #325: Term take(Loc loc) { return swap(loc, VOID); } #326: // Allocation // ---------- #327: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #328: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #329: // Stringification // --------------- #330: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #331: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #332: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #333: // Evaluation // ---------- #334: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #335: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #336: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #337: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #338: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #339: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #340: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #341: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #342: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #343: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #344: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #345: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #346: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #347: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #348: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #349: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #350: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #351: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #352: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #353: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #354: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #355: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #356: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #357: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #358: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #359: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #360: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #361: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #362: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #363: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #364: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #365: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #366: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #367: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #368: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #369: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #370: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #371: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #372: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #373: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #374: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #375: // Primitives // ---------- #376: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #377: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #378: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #379: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #380: // Runtime Memory // -------------- #381: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #382: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #383: State* hvm_get_state() { return &HVM; } #384: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #385: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #386: -- //./Type.hs// #387: module HVML.Extract where #388: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #389: import Debug.Trace #390: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #391: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #392: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #393: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #394: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #395: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #396: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #397: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #398: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #399: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #400: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #401: -- Lifting Dups -- ------------ #402: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #403: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #404: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #405: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #406: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #407: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #408: module HVML.Equal where #409: import Control.Monad (liftM2) import HVML.Type import HVML.Show #410: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #411: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #412: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #413: -- //./Type.hs// #414: module HVML.Inject where #415: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #416: type InjectM a = StateT InjectState HVM a #417: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #418: emptyState :: InjectState emptyState = InjectState Map.empty [] #419: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #420: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #421: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #422: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #423: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #424: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #425: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #426: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #427: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #428: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #429: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #430: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #431: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #432: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #433: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #434: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ((Bool, [(Bool, String)]), Core)) parseDef = do copy <- option False $ do try $ do consume "!" return True try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, ((copy,args), core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ((Bool, [(Bool,String)]), Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ((Bool,[(Bool,String)]), Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ((Bool,[(Bool,String)]), Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, ((copy,args), core)) -> (mget nameToId' name, ((copy,args), lexify (setRefIds nameToId' core)))) defs idToLabs' = MS.fromList $ map (\(name, (_, core)) -> (mget nameToId' name, collectLabels core)) defs in Book idToFunc' idToName' idToLabs' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Collects all SUP/DUP labels used collectLabels :: Core -> MS.Map Word64 () collectLabels term = case term of Var _ -> MS.empty U32 _ -> MS.empty Chr _ -> MS.empty Era -> MS.empty Ref "SUP" _SUP_F_ _ -> MS.singleton maxBound () Ref "DUP" _DUP_F_ _ -> MS.singleton maxBound () Ref _ _ args -> MS.unions $ map collectLabels args Let _ _ val bod -> MS.union (collectLabels val) (collectLabels bod) Lam _ bod -> collectLabels bod App fun arg -> MS.union (collectLabels fun) (collectLabels arg) Sup lab tm0 tm1 -> MS.insert lab () $ MS.union (collectLabels tm0) (collectLabels tm1) Dup lab _ _ val bod -> MS.insert lab () $ MS.union (collectLabels val) (collectLabels bod) Typ _ typ -> collectLabels typ Ann val typ -> MS.union (collectLabels val) (collectLabels typ) Ctr _ fds -> MS.unions $ map collectLabels fds Mat val mov css -> MS.unions $ collectLabels val : map (collectLabels . snd) mov ++ map (\(_,_,bod) -> collectLabels bod) css Op2 _ x y -> MS.union (collectLabels x) (collectLabels y) #116: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #117: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #118: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #119: -- Errors -- ------ #120: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #121: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #122: -- //./Type.hs// #123: module HVML.Reduce where #124: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #125: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #126: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari oterwise -> case MS.lookup fid (idToFunc book) of Just ((copy, args), core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms -- TODO: I disabled Fast Copy Optimization on interpreted mode because I -- don't think it is relevant here. We use it for speed, to trigger the -- hot paths on compiled functions, which don't happen when interpreted. -- I think leaving it out is good because it ensures interpreted mode is -- always optimal (minimizing interactions). This also allows the dev to -- see how Fast Copy Mode affects the interaction count. -- let inject = doInjectCoreAt book core host $ zip (map snd args) argTerms -- Fast Copy Optimization -- if copy then do -- let supGet = \x (idx,sup) -> if tagT (termTag sup) == SUP then Just (idx,sup) else x -- let supGot = foldl' supGet Nothing $ zip [0..] argTerms -- case supGot of -- Just (idx,sup) -> do -- let isCopySafe = case MS.lookup fid (idToLabs book) of -- Nothing -> False -- Just labs -> not $ MS.member (termLab sup) labs -- if isCopySafe then do -- term <- reduceRefSup term idx -- set host term -- return term -- else inject -- otherwise -> inject -- else inject Nothing -> do return term #127: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #128: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #129: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #130: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #131: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #132: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #133: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #134: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #135: -- //./Type.hs// -- //./Reduce.hs// #136: module HVML.Compile where #137: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #138: import Debug.Trace #139: -- Compilation -- ----------- #140: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #141: type Compile = State CompileState #142: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #143: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let copy = fst (fst (mget (idToFunc book) fid)) in let args = snd (fst (mget (idToFunc book) fid)) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core copy args) state in unlines $ reverse $ code (snd result) #144: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #145: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #146: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #147: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #148: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #149: -- Full Compiler -- ------------- #150: compileFull :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFull book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #151: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #152: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #153: -- Fast Compiler -- ------------- #154: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileFast book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, (strict, arg)) -> do argNam <- fresh "arg" if strict then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" if copy && strict then do case MS.lookup fid (idToLabs book) of Just labs -> do emit $ "if (term_tag(" ++ argNam ++ ") == SUP) {" tabInc emit $ "u64 lab = term_lab(" ++ argNam ++ ");" emit $ "if (1" forM_ (MS.keys labs) $ \lab -> do emit $ " && lab != " ++ show lab emit $ ") {" tabInc emit $ "Term term = reduce_ref_sup(ref, " ++ show i ++ ");" emit $ "return term;" tabDec emit $ "}" tabDec emit $ "}" Nothing -> return () else return () bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #155: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #156: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #157: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #158: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #159: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #160: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do emit $ "itrs += 1;" bind var valT STRI -> do valNam <- fresh "val" emit $ "itrs += 1;" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do -- Inline Dynamic SUP if rNam == "SUP" then do let [lab, tm0, tm1] = rArg supNam <- fresh "sup" labNam <- fresh "lab" supLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 1;" emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, term_loc(" ++ labNam ++ "), " ++ supNam ++ ")" -- Inline Dynamic DUP else if rNam == "DUP" && (case rArg of [_, _, Lam _ (Lam _ _)] -> True ; _ -> False) then do let [lab, val, Lam x (Lam y body)] = rArg dupNam <- fresh "dup" labNam <- fresh "lab" dupLoc <- compileFastAlloc 2 reuse labT <- compileFastCore book fid lab reuse emit $ "Term " ++ labNam ++ " = reduce(" ++ labT ++ ");" emit $ "if (term_tag(" ++ labNam ++ ") != W32) {" emit $ " printf(\"ERROR:non-numeric-sup-label\\n\");" emit $ "}" emit $ "itrs += 3;" emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind x $ "term_new(DP0, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" bind y $ "term_new(DP1, term_loc(" ++ labNam ++ "), " ++ dupNam ++ " + 0)" compileFastCore book fid body reuse -- Create REF node else do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #161: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #162: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> Bool -> [(Bool,String)] -> Compile () compileSlow book fid core copy args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #163: -- Type.hs: -- //./Type.hs// #164: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #165: module Main where #166: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #167: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #168: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #169: -- Main -- ---- #170: data RunMode = Normalize | Collapse | Search deriving Eq #171: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #172: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #173: -- CLI Commands -- ------------ #174: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #175: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #176: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #177: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #178: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #179: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #180: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #181: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #182: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #183: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #184: when (mode /= Normalize) $ do putStrLn "" #185: -- Prints total time end <- getCPUTime #186: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #187: -- Finalize hvmFree return $ Right () #188: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #189: module HVML.Type where #190: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #191: -- Core Types -- ---------- #192: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #193: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #194: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #195: -- A top-level function, including: -- - copy: true when ref-copy mode is enabled -- - args: a list of (isArgStrict, argName) pairs -- - core: the function's body -- Note: ref-copy improves C speed, but increases interaction count type Func = ((Bool, [(Bool,String)]), Core) #196: -- NOTE: the new idToLabs field is a map from a function id to a set of all -- DUP/SUP labels used in its body. note that, when a function uses either -- HVM.SUP or HVM.DUP internally, this field is set to Nothing. this will be -- used to apply the fast DUP-REF and REF-SUP interactions, when safe to do so data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , idToLabs :: MS.Map Word64 (MS.Map Word64 ()) , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #197: -- Runtime Types -- ------------- #198: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #199: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #200: type HVM = IO #201: type ReduceAt = Book -> Loc -> HVM Term #202: -- C Functions -- ----------- #203: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #204: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #205: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #206: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #207: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #210: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #211: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #213: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #214: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #215: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #216: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #217: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #219: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #220: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_dup_ref" reduceDupRef :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #258: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #259: foreign import ccall unsafe "Runtime.c reduce_ref_sup" reduceRefSup :: Term -> Word64 -> IO Term #260: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #261: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #262: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #263: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #264: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #265: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #266: -- Constants -- --------- #267: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #268: _DP0_ :: Tag _DP0_ = 0x00 #269: _DP1_ :: Tag _DP1_ = 0x01 #270: _VAR_ :: Tag _VAR_ = 0x02 #271: _SUB_ :: Tag _SUB_ = 0x03 #272: _REF_ :: Tag _REF_ = 0x04 #273: _LET_ :: Tag _LET_ = 0x05 #274: _APP_ :: Tag _APP_ = 0x06 #275: _ANN_ :: Tag _ANN_ = 0x07 #276: _MAT_ :: Tag _MAT_ = 0x08 #277: _OPX_ :: Tag _OPX_ = 0x09 #278: _OPY_ :: Tag _OPY_ = 0x0A #279: _ERA_ :: Tag _ERA_ = 0x0B #280: _LAM_ :: Tag _LAM_ = 0x0C #281: _SUP_ :: Tag _SUP_ = 0x0D #282: _TYP_ :: Tag _TYP_ = 0x0E #283: _CTR_ :: Tag _CTR_ = 0x0F #284: _W32_ :: Tag _W32_ = 0x10 #285: _CHR_ :: Tag _CHR_ = 0x11 #286: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #287: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #288: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #289: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #290: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #291: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] #292: -- Utils -- ----- #293: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #294: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 ./Runtime.c #295: //./Type.hs// #296: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #297: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #298: typedef _Atomic(Term) ATerm; #299: // Runtime Types // ------------- #300: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #301: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #302: // Constants // --------- #303: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #304: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #305: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #306: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #307: #define VOID 0x00000000000000 #308: // Heap // ---- #309: Loc get_len() { return *HVM.size; } #310: u64 get_itr() { return *HVM.itrs; } #311: u64 fresh() { return (*HVM.frsh)++; } #312: void set_len(Loc value) { *HVM.size = value; } #313: void set_itr(Loc value) { *HVM.itrs = value; } #314: // Terms // ------ #315: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #316: Tag term_tag(Term x) { return x & 0x7F; } #317: Tag term_bit(Term x) { return (x >> 7) & 1; } #318: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #319: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #320: Term term_set_bit(Term term) { return term | (1ULL << 7); } #321: // u12v2 // ----- #322: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #323: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #324: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #325: // Atomics // ------- #326: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #327: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #328: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #329: Term take(Loc loc) { return swap(loc, VOID); } #330: // Allocation // ---------- #331: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #332: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #333: // Stringification // --------------- #334: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #335: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #336: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #337: // Evaluation // ---------- #338: // @foo(&L{ax ay} b c ...) // ----------------------- REF-SUP (when @L not in @foo) // ! &L{bx by} = b // ! &L{cx cy} = b // ... // &L{@foo(ax bx cx ...) @foo(ay by cy ...)} // TODO: implement this in an index-generic way. // that is, receive the index where the SUP is. // clone all other indexes with a DUP Term reduce_ref_sup(Term ref, u32 idx) { inc_itr(); Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 fun_id = u12v2_x(ref_lab); u64 arity = u12v2_y(ref_lab); if (idx >= arity) { printf("ERROR: Invalid index in reduce_ref_sup\n"); exit(1); } Term sup = got(ref_loc + idx); if (term_tag(sup) != SUP) { printf("ERROR: Expected SUP at index %u\n", idx); exit(1); } Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Term sup0 = got(sup_loc + 0); Term sup1 = got(sup_loc + 1); // Allocate space for new REF node arguments for the second branch Loc ref1_loc = alloc_node(arity); for (u64 i = 0; i < arity; ++i) { if (i != idx) { // Duplicate argument Term arg = got(ref_loc + i); Loc dup_loc = alloc_node(2); set(dup_loc + 0, arg); set(dup_loc + 1, term_new(SUB, 0, 0)); set(ref_loc + i, term_new(DP0, sup_lab, dup_loc)); set(ref1_loc + i, term_new(DP1, sup_lab, dup_loc)); } else { // Set the SUP components directly set(ref_loc + i, sup0); set(ref1_loc + i, sup1); } } // Create new REF nodes Term ref0 = term_new(REF, ref_lab, ref_loc); Term ref1 = term_new(REF, ref_lab, ref1_loc); // Reuse sup_loc to create the new SUP node set(sup_loc + 0, ref0); set(sup_loc + 1, ref1); return term_new(SUP, sup_lab, sup_loc); } #339: // @foo(a b c ...) // -------------------- REF // book[foo](a b c ...) Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #340: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #341: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #342: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #343: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #344: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #345: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #346: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #347: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #348: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #349: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #350: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #351: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #352: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #353: // ! &L{x y} = @foo(a b c ...) // --------------------------- DUP-REF (when &L not in @foo) // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- @foo(a0 b0 c0 ...) // y <- @foo(a1 b1 c1 ...) Term reduce_dup_ref(Term dup, Term ref) { //printf("reduce_dup_ref "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ref_loc = term_loc(ref); Lab ref_lab = term_lab(ref); u64 ref_ari = u12v2_y(ref_lab); Loc ref0 = ref_loc; Loc ref1 = alloc_node(1 + ref_ari); for (u64 i = 0; i < ref_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ref_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ref0 + i, term_new(DP0, dup_lab, du0)); set(ref1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(REF, ref_lab, ref0)); set(dup_loc + 1, term_new(REF, ref_lab, ref1)); return got(dup_loc + dup_num); } #354: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #355: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #356: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #357: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #358: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #359: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #360: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #361: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #362: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #363: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #364: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #365: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #366: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #367: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #368: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #369: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #370: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #371: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #372: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #373: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #374: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #375: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #376: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #377: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #378: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #379: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #380: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #381: // Primitives // ---------- #382: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-sup-label\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #383: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR:non-numeric-dup-label\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Term bod_term = got(ref_loc + 2); if (term_tag(bod_term) == LAM) { Loc lam1_loc = term_loc(bod_term); Term lam1_bod = got(lam1_loc + 1); if (term_tag(lam1_bod) == LAM) { Loc lam2_loc = term_loc(lam1_bod); Term lam2_bod = got(lam2_loc + 1); set(lam1_loc + 0, term_new(DP0, term_loc(lab), dup)); set(lam2_loc + 0, term_new(DP1, term_loc(lab), dup)); *HVM.itrs += 2; return lam2_bod; } } Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); #384: } #385: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #386: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #387: // Runtime Memory // -------------- #388: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #389: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #390: State* hvm_get_state() { return &HVM; } #391: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #392: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #393: -- //./Type.hs// #394: module HVML.Extract where #395: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #396: import Debug.Trace #397: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #398: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #399: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #400: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #401: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #402: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #403: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #404: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #405: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #406: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #407: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #408: -- Lifting Dups -- ------------ #409: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #410: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #411: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #412: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #413: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #414: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #415: module HVML.Equal where #416: import Control.Monad (liftM2) import HVML.Type import HVML.Show #417: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #418: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #419: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #420: -- //./Type.hs// #421: module HVML.Inject where #422: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #423: type InjectM a = StateT InjectState HVM a #424: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #425: emptyState :: InjectState emptyState = InjectState Map.empty [] #426: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #427: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #428: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #429: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #430: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #431: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #432: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #433: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #434: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #435: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #436: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #437: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #438: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #439: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #440: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #441: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

1f85173881a5c7042ab609cb08e8bdbf35a7c692

top-level function strict arguments

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Inject.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #166: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: type Func = ([String], Core) #195: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #216: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #217: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #219: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #258: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #259: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #260: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #261: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #262: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #263: -- Constants -- --------- #264: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #265: _DP0_ :: Tag _DP0_ = 0x00 #266: _DP1_ :: Tag _DP1_ = 0x01 #267: _VAR_ :: Tag _VAR_ = 0x02 #268: _SUB_ :: Tag _SUB_ = 0x03 #269: _REF_ :: Tag _REF_ = 0x04 #270: _LET_ :: Tag _LET_ = 0x05 #271: _APP_ :: Tag _APP_ = 0x06 #272: _ANN_ :: Tag _ANN_ = 0x07 #273: _MAT_ :: Tag _MAT_ = 0x08 #274: _OPX_ :: Tag _OPX_ = 0x09 #275: _OPY_ :: Tag _OPY_ = 0x0A #276: _ERA_ :: Tag _ERA_ = 0x0B #277: _LAM_ :: Tag _LAM_ = 0x0C #278: _SUP_ :: Tag _SUP_ = 0x0D #279: _TYP_ :: Tag _TYP_ = 0x0E #280: _CTR_ :: Tag _CTR_ = 0x0F #281: _W32_ :: Tag _W32_ = 0x10 #282: _CHR_ :: Tag _CHR_ = 0x11 #283: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #284: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #285: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 #286: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #287: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #288: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #289: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #290: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #291: //./Type.hs// #292: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #293: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #294: typedef _Atomic(Term) ATerm; #295: // Runtime Types // ------------- #296: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #297: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #298: // Constants // --------- #299: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #300: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #301: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #302: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #303: #define VOID 0x00000000000000 #304: // Heap // ---- #305: Loc get_len() { return *HVM.size; } #306: u64 get_itr() { return *HVM.itrs; } #307: u64 fresh() { return (*HVM.frsh)++; } #308: void set_len(Loc value) { *HVM.size = value; } #309: void set_itr(Loc value) { *HVM.itrs = value; } #310: // Terms // ------ #311: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #312: Tag term_tag(Term x) { return x & 0x7F; } #313: Tag term_bit(Term x) { return (x >> 7) & 1; } #314: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #315: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #316: Term term_set_bit(Term term) { return term | (1ULL << 7); } #317: // u12v2 // ----- #318: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #319: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #320: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #321: // Atomics // ------- #322: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #323: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #324: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #325: Term take(Loc loc) { return swap(loc, VOID); } #326: // Allocation // ---------- #327: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #328: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #329: // Stringification // --------------- #330: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #331: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #332: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #333: // Evaluation // ---------- #334: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #335: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #336: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #337: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #338: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #339: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #340: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #341: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #342: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #343: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #344: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #345: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #346: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #347: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #348: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #349: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #350: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #351: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #352: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #353: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #354: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #355: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #356: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #357: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #358: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #359: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #360: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #361: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #362: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #363: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #364: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #365: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #366: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #367: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #368: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #369: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #370: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #371: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #372: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #373: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #374: // Primitives // ---------- #375: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #376: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #377: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #378: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #379: // Runtime Memory // -------------- #380: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #381: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #382: State* hvm_get_state() { return &HVM; } #383: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #384: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #385: -- //./Type.hs// #386: module HVML.Extract where #387: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #388: import Debug.Trace #389: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #390: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #391: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #392: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #393: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #394: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #395: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #396: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #397: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #398: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #399: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #400: -- Lifting Dups -- ------------ #401: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #402: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #403: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #404: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #405: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #406: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #407: module HVML.Equal where #408: import Control.Monad (liftM2) import HVML.Type import HVML.Show #409: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #410: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #411: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #412: -- //./Type.hs// #413: module HVML.Inject where #414: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #415: type InjectM a = StateT InjectState HVM a #416: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #417: emptyState :: InjectState emptyState = InjectState Map.empty [] #418: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #419: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #420: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #421: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #422: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #423: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #424: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #425: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #426: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #427: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #428: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #429: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #430: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #431: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #432: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #433: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ([(Bool, String)], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" strict <- option False $ do try $ do consume "!" return True arg <- parseName return (strict, arg) consume ")" return args skip consume "=" core <- parseCore return (name, (args, core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ([(Bool,String)], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([(Bool,String)], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ([(Bool,String)], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\(name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (args, core) -> do incItr when (length args /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure argTerms <- if ari == 0 then return [] else forM (zip [0..] args) $ \(i, (strict, _)) -> do term <- got (loc + i) if strict then reduceAt False book (loc + i) else return term doInjectCoreAt book core host $ zip (map snd args) argTerms Nothing -> return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Inject.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [(Bool,String)] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do let argName = snd arg let argTerm = if fst arg then "reduce_at(term_loc(ref) + " ++ show i ++ ")" else "got(term_loc(ref) + " ++ show i ++ ")" bind argName argTerm result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" -- TODO: if it is a strict argument, use "reduce_at" instead of "got" if fst arg then do emit $ "Term " ++ argNam ++ " = reduce_at(term_loc(ref) + " ++ show i ++ ");" else do emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind (snd arg) argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [(Bool,String)] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #166: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: type Func = ([(Bool,String)], Core) #195: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #216: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #217: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #219: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #258: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #259: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #260: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #261: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #262: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #263: -- Constants -- --------- #264: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #265: _DP0_ :: Tag _DP0_ = 0x00 #266: _DP1_ :: Tag _DP1_ = 0x01 #267: _VAR_ :: Tag _VAR_ = 0x02 #268: _SUB_ :: Tag _SUB_ = 0x03 #269: _REF_ :: Tag _REF_ = 0x04 #270: _LET_ :: Tag _LET_ = 0x05 #271: _APP_ :: Tag _APP_ = 0x06 #272: _ANN_ :: Tag _ANN_ = 0x07 #273: _MAT_ :: Tag _MAT_ = 0x08 #274: _OPX_ :: Tag _OPX_ = 0x09 #275: _OPY_ :: Tag _OPY_ = 0x0A #276: _ERA_ :: Tag _ERA_ = 0x0B #277: _LAM_ :: Tag _LAM_ = 0x0C #278: _SUP_ :: Tag _SUP_ = 0x0D #279: _TYP_ :: Tag _TYP_ = 0x0E #280: _CTR_ :: Tag _CTR_ = 0x0F #281: _W32_ :: Tag _W32_ = 0x10 #282: _CHR_ :: Tag _CHR_ = 0x11 #283: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #284: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #285: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 #286: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #287: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #288: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #289: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #290: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #291: //./Type.hs// #292: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #293: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #294: typedef _Atomic(Term) ATerm; #295: // Runtime Types // ------------- #296: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #297: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #298: // Constants // --------- #299: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #300: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #301: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #302: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #303: #define VOID 0x00000000000000 #304: // Heap // ---- #305: Loc get_len() { return *HVM.size; } #306: u64 get_itr() { return *HVM.itrs; } #307: u64 fresh() { return (*HVM.frsh)++; } #308: void set_len(Loc value) { *HVM.size = value; } #309: void set_itr(Loc value) { *HVM.itrs = value; } #310: // Terms // ------ #311: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #312: Tag term_tag(Term x) { return x & 0x7F; } #313: Tag term_bit(Term x) { return (x >> 7) & 1; } #314: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #315: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #316: Term term_set_bit(Term term) { return term | (1ULL << 7); } #317: // u12v2 // ----- #318: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #319: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #320: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #321: // Atomics // ------- #322: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #323: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #324: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #325: Term take(Loc loc) { return swap(loc, VOID); } #326: // Allocation // ---------- #327: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #328: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #329: // Stringification // --------------- #330: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #331: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #332: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #333: // Evaluation // ---------- #334: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #335: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #336: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #337: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #338: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #339: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #340: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #341: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #342: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #343: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #344: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #345: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #346: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #347: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #348: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #349: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #350: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #351: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #352: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #353: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #354: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #355: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #356: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #357: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #358: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #359: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #360: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #361: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #362: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #363: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #364: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #365: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #366: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #367: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #368: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #369: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #370: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #371: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #372: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #373: Term reduce_at(Loc host) { Term term = reduce(got(host)); set(host, term); return term; } #374: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #375: // Primitives // ---------- #376: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #377: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #378: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #379: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #380: // Runtime Memory // -------------- #381: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #382: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #383: State* hvm_get_state() { return &HVM; } #384: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #385: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #386: -- //./Type.hs// #387: module HVML.Extract where #388: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #389: import Debug.Trace #390: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #391: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #392: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #393: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #394: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #395: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #396: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #397: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #398: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #399: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #400: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #401: -- Lifting Dups -- ------------ #402: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #403: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #404: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #405: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #406: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #407: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #408: module HVML.Equal where #409: import Control.Monad (liftM2) import HVML.Type import HVML.Show #410: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #411: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #412: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #413: -- //./Type.hs// #414: module HVML.Inject where #415: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #416: type InjectM a = StateT InjectState HVM a #417: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #418: emptyState :: InjectState emptyState = InjectState Map.empty [] #419: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #420: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #421: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #422: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #423: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #424: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #425: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #426: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #427: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #428: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #429: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #430: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #431: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #432: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #433: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #434: doInjectCoreAt :: Book -> Core -> Loc -> [(String,Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

7fe17a264becaabba3ecdf06a285bad753a4bb8a

default cases on match (desugars to if-let) HVM now has a new mode for Mat, named if-let: ~ x { #Foo{..}: main-case other: default-case } it behaves as an if-let: if the first constructor matches, return the main case applied to the fields, otherwise, return default-case applied to the original value. when there is more than one case and a default, as in: ~ x { #Foo{..}: main-case #Bar{..}: main-case ... other: default-case } it gets desugared to a chain of if-lets. if-let is more lightweight than the usual mat because it avoid storing all cases in memory, but, when there are many cases covered, it might be slower as it requires additional interactions. it also allows for more concise code in some cases if-let is not optimized at all by the compiler for now

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #91: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #92: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #93: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #94: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #95: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #96: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #97: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #99: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #100: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #101: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #102: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #103: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #104: -- Helper Parsers -- -------------- #105: consume :: String -> ParserM String consume str = skip >> string str #106: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #107: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #108: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #109: -- Adjusting -- --------- #110: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #111: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #112: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #113: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #114: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #115: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #116: -- Errors -- ------ #117: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #118: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #119: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #120: module HVML.Reduce where #121: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #122: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #123: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #124: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #125: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #126: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #127: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #128: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #129: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #130: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #131: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #132: -- //./Type.hs// -- //./Inject.hs// #133: module HVML.Compile where #134: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #135: import Debug.Trace #136: -- Compilation -- ----------- #137: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #138: type Compile = State CompileState #139: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #140: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #141: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #142: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #143: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #144: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #145: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #146: -- Full Compiler -- ------------- #147: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #148: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #149: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #150: -- Fast Compiler -- ------------- #151: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #152: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #153: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #154: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #155: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #156: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #157: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #158: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #159: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #160: -- Type.hs: -- //./Type.hs// #161: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #162: module Main where #163: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #164: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #165: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #166: -- Main -- ---- #167: data RunMode = Normalize | Collapse | Search deriving Eq #168: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #169: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #170: -- CLI Commands -- ------------ #171: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #172: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #173: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #174: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #175: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #176: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #177: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #178: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #179: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #180: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #181: when (mode /= Normalize) $ do putStrLn "" #182: -- Prints total time end <- getCPUTime #183: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #184: -- Finalize hvmFree return $ Right () #185: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #186: module HVML.Type where #187: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #188: -- Core Types -- ---------- #189: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #190: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #191: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #192: type Func = ([String], Core) #193: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #194: -- Runtime Types -- ------------- #195: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #196: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #197: type HVM = IO #198: type ReduceAt = Book -> Loc -> HVM Term #199: -- C Functions -- ----------- #200: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #201: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #202: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #203: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #204: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #205: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #206: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #208: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #209: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #210: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #211: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #212: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #213: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #214: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #215: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #216: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #217: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #256: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #257: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #258: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #259: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #260: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #261: -- Constants -- --------- #262: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #263: _DP0_ :: Tag _DP0_ = 0x00 #264: _DP1_ :: Tag _DP1_ = 0x01 #265: _VAR_ :: Tag _VAR_ = 0x02 #266: _SUB_ :: Tag _SUB_ = 0x03 #267: _REF_ :: Tag _REF_ = 0x04 #268: _LET_ :: Tag _LET_ = 0x05 #269: _APP_ :: Tag _APP_ = 0x06 #270: _ANN_ :: Tag _ANN_ = 0x07 #271: _MAT_ :: Tag _MAT_ = 0x08 #272: _OPX_ :: Tag _OPX_ = 0x09 #273: _OPY_ :: Tag _OPY_ = 0x0A #274: _ERA_ :: Tag _ERA_ = 0x0B #275: _LAM_ :: Tag _LAM_ = 0x0C #276: _SUP_ :: Tag _SUP_ = 0x0D #277: _TYP_ :: Tag _TYP_ = 0x0E #278: _CTR_ :: Tag _CTR_ = 0x0F #279: _W32_ :: Tag _W32_ = 0x10 #280: _CHR_ :: Tag _CHR_ = 0x11 #281: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #282: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #283: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #284: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #285: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #286: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #287: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #288: //./Type.hs// #289: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #290: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #291: typedef _Atomic(Term) ATerm; #292: // Runtime Types // ------------- #293: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #294: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #295: // Constants // --------- #296: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #297: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #298: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #299: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #300: #define VOID 0x00000000000000 #301: // Heap // ---- #302: Loc get_len() { return *HVM.size; } #303: u64 get_itr() { return *HVM.itrs; } #304: u64 fresh() { return (*HVM.frsh)++; } #305: void set_len(Loc value) { *HVM.size = value; } #306: void set_itr(Loc value) { *HVM.itrs = value; } #307: // Terms // ------ #308: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #309: Tag term_tag(Term x) { return x & 0x7F; } #310: Tag term_bit(Term x) { return (x >> 7) & 1; } #311: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #312: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #313: Term term_set_bit(Term term) { return term | (1ULL << 7); } #314: // u12v2 // ----- #315: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #316: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #317: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #318: // Atomics // ------- #319: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #320: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #321: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #322: Term take(Loc loc) { return swap(loc, VOID); } #323: // Allocation // ---------- #324: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #325: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #326: // Stringification // --------------- #327: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #328: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #329: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #330: // Evaluation // ---------- #331: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #332: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #333: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #334: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #335: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #336: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #337: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #338: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #339: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #340: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #341: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #342: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #343: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #344: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #345: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #346: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #347: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #348: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #349: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #350: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #351: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #352: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #353: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #354: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #355: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #356: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #357: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #358: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #359: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #360: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #361: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #362: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #363: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #364: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #365: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #366: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #367: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #368: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #369: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #370: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #371: // Primitives // ---------- #372: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #373: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #374: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #375: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #376: // Runtime Memory // -------------- #377: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #378: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #379: State* hvm_get_state() { return &HVM; } #380: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #381: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #382: -- //./Type.hs// #383: module HVML.Extract where #384: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #385: import Debug.Trace #386: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #387: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #388: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #389: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #390: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #391: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #392: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #393: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #394: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #395: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #396: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #397: -- Lifting Dups -- ------------ #398: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #399: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #400: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #401: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #402: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #403: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #404: module HVML.Equal where #405: import Control.Monad (liftM2) import HVML.Type import HVML.Show #406: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #407: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #408: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #409: -- //./Type.hs// #410: module HVML.Inject where #411: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #412: type InjectM a = StateT InjectState HVM a #413: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #414: emptyState :: InjectState emptyState = InjectState Map.empty [] #415: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #416: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #417: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #418: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #419: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #420: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #421: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #422: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #423: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #424: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #425: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #426: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #427: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #428: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #429: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #430: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = u12v2X $ termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> if nam == "" then let val' = coreToString val in let bod' = coreToString bod in val' ++ "\n" ++ bod' else let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ "\n" ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.Either (isLeft) import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric or default case else do nam <- parseName1 case reads nam of -- Numeric case [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (nam, [], bod) -- Default case otherwise -> do consume ":" bod <- parseCore return ("_", [nam], bod) consume "}" css <- forM css $ \ (ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> do return $ Left (read num :: Word64) otherwise -> do st <- getState return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css #91: -- Transform matches with default cases into nested chain of matches if length css == 1 && (let (ctr, _, _) = head css in ctr == "_") then do fail "Match with only a default case is not allowed." else if (let (ctr, _, _) = last css in ctr == "_") then do let defName = (let (_,[nm],_) = last css in nm) let ifLets = intoIfLetChain (Var defName) mov (init css) defName (last css) return $ Let LAZY defName val ifLets else do return $ Mat val mov css #92: intoIfLetChain :: Core -> [(String, Core)] -> [(String, [String], Core)] -> String -> (String, [String], Core) -> Core intoIfLetChain _ _ [] defName (_,_,defBody) = defBody intoIfLetChain val mov ((ctr,fds,bod):css) defName defCase = let rest = intoIfLetChain val mov css defName defCase in Mat val mov [(ctr, fds, bod), ("_", [defName], rest)] #93: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #94: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #95: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #96: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #97: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #98: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #99: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #100: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #101: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #102: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #103: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #104: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #105: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #106: -- Helper Parsers -- -------------- #107: consume :: String -> ParserM String consume str = skip >> string str #108: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #109: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #110: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #111: -- Adjusting -- --------- #112: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #113: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #114: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #115: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #116: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #117: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #118: -- Errors -- ------ #119: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #120: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #121: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #122: module HVML.Reduce where #123: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #124: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #125: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #126: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #127: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #128: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #129: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #130: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #131: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #132: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #133: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #134: -- //./Type.hs// -- //./Inject.hs// #135: module HVML.Compile where #136: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #137: import Debug.Trace #138: -- Compilation -- ----------- #139: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #140: type Compile = State CompileState #141: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #142: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #143: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #144: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #145: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #146: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #147: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #148: -- Full Compiler -- ------------- #149: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #150: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #151: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid tm@(Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Fast Compiler -- ------------- #153: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #154: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #155: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBook book fid term@(Mat val mov css) ctx stop@False itr reuse | ifLetLab book term == 0 = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #156: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #157: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #158: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #159: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid tm@(Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, u12v2_new(" ++ show arity ++ "," ++ show (ifLetLab book tm) ++ "), " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #160: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #161: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #162: -- Type.hs: -- //./Type.hs// #163: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #164: module Main where #165: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #166: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #167: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #168: -- Main -- ---- #169: data RunMode = Normalize | Collapse | Search deriving Eq #170: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #171: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #172: -- CLI Commands -- ------------ #173: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #174: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #175: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #176: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #177: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #178: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #179: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #180: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #181: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #182: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #183: when (mode /= Normalize) $ do putStrLn "" #184: -- Prints total time end <- getCPUTime #185: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #186: -- Finalize hvmFree return $ Right () #187: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #188: module HVML.Type where #189: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #190: -- Core Types -- ---------- #191: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #192: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #193: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #194: type Func = ([String], Core) #195: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #196: -- Runtime Types -- ------------- #197: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #198: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #199: type HVM = IO #200: type ReduceAt = Book -> Loc -> HVM Term #201: -- C Functions -- ----------- #202: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #203: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #204: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #205: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #206: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #207: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #208: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #209: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #210: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #211: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #213: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #214: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #215: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #216: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #217: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #218: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #219: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #255: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #256: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #257: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #258: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #259: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #260: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #261: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #262: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #263: -- Constants -- --------- #264: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #265: _DP0_ :: Tag _DP0_ = 0x00 #266: _DP1_ :: Tag _DP1_ = 0x01 #267: _VAR_ :: Tag _VAR_ = 0x02 #268: _SUB_ :: Tag _SUB_ = 0x03 #269: _REF_ :: Tag _REF_ = 0x04 #270: _LET_ :: Tag _LET_ = 0x05 #271: _APP_ :: Tag _APP_ = 0x06 #272: _ANN_ :: Tag _ANN_ = 0x07 #273: _MAT_ :: Tag _MAT_ = 0x08 #274: _OPX_ :: Tag _OPX_ = 0x09 #275: _OPY_ :: Tag _OPY_ = 0x0A #276: _ERA_ :: Tag _ERA_ = 0x0B #277: _LAM_ :: Tag _LAM_ = 0x0C #278: _SUP_ :: Tag _SUP_ = 0x0D #279: _TYP_ :: Tag _TYP_ = 0x0E #280: _CTR_ :: Tag _CTR_ = 0x0F #281: _W32_ :: Tag _W32_ = 0x10 #282: _CHR_ :: Tag _CHR_ = 0x11 #283: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #284: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #285: -- The if-let match stores its target ctr id ifLetLab :: Book -> Core -> Word64 ifLetLab book (Mat _ _ [(ctr,_,_),("_",_,_)]) = case MS.lookup ctr (ctrToCid book) of Just cid -> 1 + cid Nothing -> 0 ifLetLab book _ = 0 #286: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #287: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #288: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #289: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #290: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #291: //./Type.hs// #292: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #293: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #294: typedef _Atomic(Term) ATerm; #295: // Runtime Types // ------------- #296: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #297: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #298: // Constants // --------- #299: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #300: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #301: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #302: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #303: #define VOID 0x00000000000000 #304: // Heap // ---- #305: Loc get_len() { return *HVM.size; } #306: u64 get_itr() { return *HVM.itrs; } #307: u64 fresh() { return (*HVM.frsh)++; } #308: void set_len(Loc value) { *HVM.size = value; } #309: void set_itr(Loc value) { *HVM.itrs = value; } #310: // Terms // ------ #311: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #312: Tag term_tag(Term x) { return x & 0x7F; } #313: Tag term_bit(Term x) { return (x >> 7) & 1; } #314: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #315: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #316: Term term_set_bit(Term term) { return term | (1ULL << 7); } #317: // u12v2 // ----- #318: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #319: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #320: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #321: // Atomics // ------- #322: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #323: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #324: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #325: Term take(Loc loc) { return swap(loc, VOID); } #326: // Allocation // ---------- #327: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #328: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #329: // Stringification // --------------- #330: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #331: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #332: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #333: // Evaluation // ---------- #334: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #335: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #336: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #337: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #338: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #339: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #340: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #341: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #342: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #343: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #344: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #345: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #346: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #347: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #348: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #349: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #350: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_lab, mat0)); set(sup0 + 1, term_new(MAT, mat_lab, mat1)); return term_new(SUP, sup_lab, sup0); } #351: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #352: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); // If-Let if (u12v2_y(mat_lab) > 0) { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 mat_ctr = u12v2_y(mat_lab) - 1; u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); if (mat_ctr == ctr_num) { Term app = got(mat_loc + 1); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } else { Term app = got(mat_loc + 2); Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, ctr); app = term_new(APP, 0, new_app); return app; } // Match } else { Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } } #353: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_lab = term_lab(mat); u64 mat_len = u12v2_x(mat_lab); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #354: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #355: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #356: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #357: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #358: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #359: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #360: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #361: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #362: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #363: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #364: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #365: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #366: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #367: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #368: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #369: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #370: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #371: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #372: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; case ANN: set(hloc + 1, next); break; case OPX: set(hloc + 0, next); break; case OPY: set(hloc + 1, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #373: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 mat_len = u12v2_x(lab); for (u64 i = 0; i <= mat_len; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #374: // Primitives // ---------- #375: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #376: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #377: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #378: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #379: // Runtime Memory // -------------- #380: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #381: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #382: State* hvm_get_state() { return &HVM; } #383: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #384: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #385: -- //./Type.hs// #386: module HVML.Extract where #387: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #388: import Debug.Trace #389: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #390: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #391: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #392: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #393: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #394: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #395: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #396: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #397: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = u12v2X $ termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #398: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #399: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #400: -- Lifting Dups -- ------------ #401: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #402: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #403: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #404: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #405: doLiftDups :: Core -> Core doLiftDups term = let (termExpr, termDups) = liftDups term in let termBody = termDups (Var "") in -- hack to print expr before dups Let LAZY "" termExpr termBody ./Equal.hs #406: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #407: module HVML.Equal where #408: import Control.Monad (liftM2) import HVML.Type import HVML.Show #409: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #410: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #411: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #412: -- //./Type.hs// #413: module HVML.Inject where #414: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #415: type InjectM a = StateT InjectState HVM a #416: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #417: emptyState :: InjectState emptyState = InjectState Map.empty [] #418: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #419: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #420: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #421: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #422: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #423: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #424: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #425: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #426: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #427: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #428: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #429: injectCore book tm@(Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Inject each case body forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (u12v2New (fromIntegral (length css)) (ifLetLab book tm)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #430: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #431: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #432: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #433: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

8d09b1b25088eacbc3c411d1e84d81170fad3555

lazy printing of infinite structures

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #91: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #92: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #93: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #94: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #95: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #96: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #97: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #99: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #100: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #101: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #102: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #103: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #104: -- Helper Parsers -- -------------- #105: consume :: String -> ParserM String consume str = skip >> string str #106: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #107: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #108: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #109: -- Adjusting -- --------- #110: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #111: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #112: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #113: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #114: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #115: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #116: -- Errors -- ------ #117: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #118: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #119: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #120: module HVML.Reduce where #121: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #122: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #123: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #124: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #125: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #126: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #127: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #128: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #129: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #130: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #131: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #132: -- //./Type.hs// -- //./Inject.hs// #133: module HVML.Compile where #134: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #135: import Debug.Trace #136: -- Compilation -- ----------- #137: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #138: type Compile = State CompileState #139: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #140: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #141: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #142: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #143: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #144: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #145: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #146: -- Full Compiler -- ------------- #147: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #148: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #149: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #150: -- Fast Compiler -- ------------- #151: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #152: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #153: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #154: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #155: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #156: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #157: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #158: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #159: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #160: -- Type.hs: -- //./Type.hs// #161: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #162: module Main where #163: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #164: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #165: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #166: -- Main -- ---- #167: data RunMode = Normalize | Collapse | Search deriving Eq #168: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #169: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #170: -- CLI Commands -- ------------ #171: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #172: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #173: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #174: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #175: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #176: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #177: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #178: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #179: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #180: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #181: -- Prints total time end <- getCPUTime #182: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #183: -- Finalize hvmFree return $ Right () #184: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #185: module HVML.Type where #186: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #187: -- Core Types -- ---------- #188: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #189: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #190: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #191: type Func = ([String], Core) #192: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #193: -- Runtime Types -- ------------- #194: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #195: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #196: type HVM = IO #197: type ReduceAt = Book -> Loc -> HVM Term #198: -- C Functions -- ----------- #199: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #200: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #201: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #202: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #203: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #204: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #205: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #206: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #207: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #208: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #209: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #210: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #211: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #213: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #214: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #215: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #216: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #255: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #256: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #257: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #258: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #259: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #260: -- Constants -- --------- #261: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #262: _DP0_ :: Tag _DP0_ = 0x00 #263: _DP1_ :: Tag _DP1_ = 0x01 #264: _VAR_ :: Tag _VAR_ = 0x02 #265: _SUB_ :: Tag _SUB_ = 0x03 #266: _REF_ :: Tag _REF_ = 0x04 #267: _LET_ :: Tag _LET_ = 0x05 #268: _APP_ :: Tag _APP_ = 0x06 #269: _ANN_ :: Tag _ANN_ = 0x07 #270: _MAT_ :: Tag _MAT_ = 0x08 #271: _OPX_ :: Tag _OPX_ = 0x09 #272: _OPY_ :: Tag _OPY_ = 0x0A #273: _ERA_ :: Tag _ERA_ = 0x0B #274: _LAM_ :: Tag _LAM_ = 0x0C #275: _SUP_ :: Tag _SUP_ = 0x0D #276: _TYP_ :: Tag _TYP_ = 0x0E #277: _CTR_ :: Tag _CTR_ = 0x0F #278: _W32_ :: Tag _W32_ = 0x10 #279: _CHR_ :: Tag _CHR_ = 0x11 #280: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #281: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #282: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #283: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #284: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #285: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #286: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #287: //./Type.hs// #288: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #289: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #290: typedef _Atomic(Term) ATerm; #291: // Runtime Types // ------------- #292: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #293: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #294: // Constants // --------- #295: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #296: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #297: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #298: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #299: #define VOID 0x00000000000000 #300: // Heap // ---- #301: Loc get_len() { return *HVM.size; } #302: u64 get_itr() { return *HVM.itrs; } #303: u64 fresh() { return (*HVM.frsh)++; } #304: void set_len(Loc value) { *HVM.size = value; } #305: void set_itr(Loc value) { *HVM.itrs = value; } #306: // Terms // ------ #307: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #308: Tag term_tag(Term x) { return x & 0x7F; } #309: Tag term_bit(Term x) { return (x >> 7) & 1; } #310: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #311: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #312: Term term_set_bit(Term term) { return term | (1ULL << 7); } #313: // u12v2 // ----- #314: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #315: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #316: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #317: // Atomics // ------- #318: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #319: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #320: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #321: Term take(Loc loc) { return swap(loc, VOID); } #322: // Allocation // ---------- #323: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #324: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #325: // Stringification // --------------- #326: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #327: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #328: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #329: // Evaluation // ---------- #330: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #336: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #337: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #338: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #339: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #340: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #341: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #342: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #343: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #344: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #345: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #346: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #347: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #348: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #349: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #350: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #351: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #352: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #353: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #354: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #355: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #356: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #357: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #358: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #359: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #360: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #361: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #362: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #363: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #364: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #365: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #366: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #367: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #368: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #369: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #370: // Primitives // ---------- #371: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #372: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #373: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #374: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #375: // Runtime Memory // -------------- #376: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #377: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #378: State* hvm_get_state() { return &HVM; } #379: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #380: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #381: -- //./Type.hs// -- //./Inject.hs// #382: module HVML.Extract where #383: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #384: import Debug.Trace #385: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #386: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #387: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #388: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #389: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #390: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #391: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #392: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #393: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #394: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #395: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #396: -- Lifting Dups -- ------------ #397: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #398: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #399: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #400: module HVML.Equal where #401: import Control.Monad (liftM2) import HVML.Type import HVML.Show #402: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #403: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #404: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #405: -- //./Type.hs// #406: module HVML.Inject where #407: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #408: type InjectM a = StateT InjectState HVM a #409: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #410: emptyState :: InjectState emptyState = InjectState Map.empty [] #411: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #412: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #413: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #414: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #415: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #416: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #417: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #418: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #419: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #420: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #421: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #422: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #423: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #424: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #425: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #426: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #91: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #92: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #93: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #94: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #95: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #96: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #97: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #99: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #100: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #101: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #102: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #103: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #104: -- Helper Parsers -- -------------- #105: consume :: String -> ParserM String consume str = skip >> string str #106: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #107: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #108: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #109: -- Adjusting -- --------- #110: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #111: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #112: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #113: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #114: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #115: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #116: -- Errors -- ------ #117: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #118: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #119: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #120: module HVML.Reduce where #121: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #122: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #123: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #124: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #125: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #126: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #127: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #128: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #129: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #130: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #131: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #132: -- //./Type.hs// -- //./Inject.hs// #133: module HVML.Compile where #134: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #135: import Debug.Trace #136: -- Compilation -- ----------- #137: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #138: type Compile = State CompileState #139: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #140: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #141: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #142: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #143: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #144: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #145: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #146: -- Full Compiler -- ------------- #147: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #148: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #149: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #150: -- Fast Compiler -- ------------- #151: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #152: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #153: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #154: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #155: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #156: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #157: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #158: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #159: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #160: -- Type.hs: -- //./Type.hs// #161: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #162: module Main where #163: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #164: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #165: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #166: -- Main -- ---- #167: data RunMode = Normalize | Collapse | Search deriving Eq #168: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #169: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #170: -- CLI Commands -- ------------ #171: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #172: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #173: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #174: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #175: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #176: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #177: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #178: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #179: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #180: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #181: -- Prints total time end <- getCPUTime #182: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #183: -- Finalize hvmFree return $ Right () #184: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #185: module HVML.Type where #186: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #187: -- Core Types -- ---------- #188: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #189: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #190: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #191: type Func = ([String], Core) #192: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #193: -- Runtime Types -- ------------- #194: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #195: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #196: type HVM = IO #197: type ReduceAt = Book -> Loc -> HVM Term #198: -- C Functions -- ----------- #199: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #200: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #201: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #202: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #203: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #204: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #205: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #206: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #207: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #208: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #209: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #210: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #211: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #213: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #214: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #215: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #216: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #255: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #256: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #257: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #258: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #259: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #260: -- Constants -- --------- #261: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #262: _DP0_ :: Tag _DP0_ = 0x00 #263: _DP1_ :: Tag _DP1_ = 0x01 #264: _VAR_ :: Tag _VAR_ = 0x02 #265: _SUB_ :: Tag _SUB_ = 0x03 #266: _REF_ :: Tag _REF_ = 0x04 #267: _LET_ :: Tag _LET_ = 0x05 #268: _APP_ :: Tag _APP_ = 0x06 #269: _ANN_ :: Tag _ANN_ = 0x07 #270: _MAT_ :: Tag _MAT_ = 0x08 #271: _OPX_ :: Tag _OPX_ = 0x09 #272: _OPY_ :: Tag _OPY_ = 0x0A #273: _ERA_ :: Tag _ERA_ = 0x0B #274: _LAM_ :: Tag _LAM_ = 0x0C #275: _SUP_ :: Tag _SUP_ = 0x0D #276: _TYP_ :: Tag _TYP_ = 0x0E #277: _CTR_ :: Tag _CTR_ = 0x0F #278: _W32_ :: Tag _W32_ = 0x10 #279: _CHR_ :: Tag _CHR_ = 0x11 #280: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #281: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #282: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #283: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #284: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #285: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #286: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #287: //./Type.hs// #288: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #289: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #290: typedef _Atomic(Term) ATerm; #291: // Runtime Types // ------------- #292: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #293: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #294: // Constants // --------- #295: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #296: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #297: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #298: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #299: #define VOID 0x00000000000000 #300: // Heap // ---- #301: Loc get_len() { return *HVM.size; } #302: u64 get_itr() { return *HVM.itrs; } #303: u64 fresh() { return (*HVM.frsh)++; } #304: void set_len(Loc value) { *HVM.size = value; } #305: void set_itr(Loc value) { *HVM.itrs = value; } #306: // Terms // ------ #307: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #308: Tag term_tag(Term x) { return x & 0x7F; } #309: Tag term_bit(Term x) { return (x >> 7) & 1; } #310: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #311: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #312: Term term_set_bit(Term term) { return term | (1ULL << 7); } #313: // u12v2 // ----- #314: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #315: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #316: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #317: // Atomics // ------- #318: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #319: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #320: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #321: Term take(Loc loc) { return swap(loc, VOID); } #322: // Allocation // ---------- #323: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #324: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #325: // Stringification // --------------- #326: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #327: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #328: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #329: // Evaluation // ---------- #330: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #336: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #337: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #338: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #339: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #340: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #341: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #342: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #343: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #344: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #345: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #346: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #347: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #348: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #349: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #350: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #351: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #352: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #353: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #354: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #355: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #356: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #357: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #358: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #359: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #360: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #361: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #362: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #363: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #364: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #365: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #366: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #367: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #368: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #369: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #370: // Primitives // ---------- #371: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #372: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #373: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #374: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #375: // Runtime Memory // -------------- #376: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #377: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #378: State* hvm_get_state() { return &HVM; } #379: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #380: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #381: -- //./Type.hs// #382: module HVML.Extract where #383: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #384: import Debug.Trace #385: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #386: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #387: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #388: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #389: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #390: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #391: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #392: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #393: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #394: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #395: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #396: -- Lifting Dups -- ------------ #397: liftDups :: Core -> (Core, Core -> Core) liftDups (Var nam) = (Var nam, id) liftDups (Ref nam fid arg) = let (argT, argD) = liftDupsList arg in (Ref nam fid argT, argD) liftDups Era = (Era, id) liftDups (Lam str bod) = let (bodT, bodD) = liftDups bod in (Lam str bodT, bodD) liftDups (App fun arg) = let (funT, funD) = liftDups fun (argT, argD) = liftDups arg in (App funT argT, funD . argD) liftDups (Sup lab tm0 tm1) = let (tm0T, tm0D) = liftDups tm0 (tm1T, tm1D) = liftDups tm1 in (Sup lab tm0T tm1T, tm0D . tm1D) liftDups (Dup lab dp0 dp1 val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (bodT, \x -> valD (bodD (Dup lab dp0 dp1 valT x))) liftDups (Typ nam bod) = let (bodT, bodD) = liftDups bod in (Typ nam bodT, bodD) liftDups (Ann val typ) = let (valT, valD) = liftDups val (typT, typD) = liftDups typ in (Ann valT typT, valD . typD) liftDups (Ctr cid fds) = let (fdsT, fdsD) = liftDupsList fds in (Ctr cid fdsT, fdsD) liftDups (Mat val mov css) = let (valT, valD) = liftDups val (movT, movD) = liftDupsMov mov (cssT, cssD) = liftDupsCss css in (Mat valT movT cssT, valD . movD . cssD) liftDups (U32 val) = (U32 val, id) liftDups (Chr val) = (Chr val, id) liftDups (Op2 opr nm0 nm1) = let (nm0T, nm0D) = liftDups nm0 (nm1T, nm1D) = liftDups nm1 in (Op2 opr nm0T nm1T, nm0D . nm1D) liftDups (Let mod nam val bod) = let (valT, valD) = liftDups val (bodT, bodD) = liftDups bod in (Let mod nam valT bodT, valD . bodD) #398: liftDupsList :: [Core] -> ([Core], Core -> Core) liftDupsList [] = ([], id) liftDupsList (x:xs) = let (xT, xD) = liftDups x (xsT, xsD) = liftDupsList xs in (xT:xsT, xD . xsD) #399: liftDupsMov :: [(String, Core)] -> ([(String, Core)], Core -> Core) liftDupsMov [] = ([], id) liftDupsMov ((k,v):xs) = let (vT, vD) = liftDups v (xsT, xsD) = liftDupsMov xs in ((k,vT):xsT, vD . xsD) #400: liftDupsCss :: [(String, [String], Core)] -> ([(String, [String], Core)], Core -> Core) liftDupsCss [] = ([], id) liftDupsCss ((c,fs,b):xs) = let (bT, bD) = liftDups b (xsT, xsD) = liftDupsCss xs in ((c,fs,bT):xsT, bD . xsD) #401: doLiftDups :: Core -> Core doLiftDups term = let (termBody, termDups) = liftDups term in Let LAZY "main" termBody (termDups (Var "main")) ./Equal.hs #402: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #403: module HVML.Equal where #404: import Control.Monad (liftM2) import HVML.Type import HVML.Show #405: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #406: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #407: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #408: -- //./Type.hs// #409: module HVML.Inject where #410: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #411: type InjectM a = StateT InjectState HVM a #412: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #413: emptyState :: InjectState emptyState = InjectState Map.empty [] #414: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #415: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #416: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #417: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #418: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #419: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #420: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #421: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #422: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #423: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #424: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #425: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #426: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #427: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #428: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #429: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

2dc2b7d4ee4d0c1556806876e46e6e1bc3af4a6c

fix comment parsing issues

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #91: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #92: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #93: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #94: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #95: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #96: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #97: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #99: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #100: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #101: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #102: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #103: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #104: -- Helper Parsers -- -------------- #105: consume :: String -> ParserM String consume str = spaces >> string str #106: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #107: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #108: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #109: -- Adjusting -- --------- #110: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #111: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #112: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #113: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #114: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #115: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #116: -- Errors -- ------ #117: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #118: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #119: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #120: module HVML.Reduce where #121: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #122: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #123: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #124: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #125: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #126: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #127: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #128: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #129: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #130: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #131: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #132: -- //./Type.hs// -- //./Inject.hs// #133: module HVML.Compile where #134: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #135: import Debug.Trace #136: -- Compilation -- ----------- #137: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #138: type Compile = State CompileState #139: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #140: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #141: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #142: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #143: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #144: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #145: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #146: -- Full Compiler -- ------------- #147: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #148: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #149: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #150: -- Fast Compiler -- ------------- #151: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #152: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #153: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #154: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #155: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #156: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #157: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #158: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #159: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #160: -- Type.hs: -- //./Type.hs// #161: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #162: module Main where #163: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #164: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #165: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #166: -- Main -- ---- #167: data RunMode = Normalize | Collapse | Search deriving Eq #168: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #169: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #170: -- CLI Commands -- ------------ #171: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #172: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #173: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #174: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #175: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #176: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #177: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #178: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #179: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #180: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #181: -- Prints total time end <- getCPUTime #182: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #183: -- Finalize hvmFree return $ Right () #184: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #185: module HVML.Type where #186: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #187: -- Core Types -- ---------- #188: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #189: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #190: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #191: type Func = ([String], Core) #192: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #193: -- Runtime Types -- ------------- #194: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #195: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #196: type HVM = IO #197: type ReduceAt = Book -> Loc -> HVM Term #198: -- C Functions -- ----------- #199: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #200: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #201: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #202: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #203: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #204: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #205: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #206: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #207: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #208: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #209: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #210: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #211: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #213: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #214: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #215: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #216: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #255: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #256: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #257: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #258: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #259: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #260: -- Constants -- --------- #261: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #262: _DP0_ :: Tag _DP0_ = 0x00 #263: _DP1_ :: Tag _DP1_ = 0x01 #264: _VAR_ :: Tag _VAR_ = 0x02 #265: _SUB_ :: Tag _SUB_ = 0x03 #266: _REF_ :: Tag _REF_ = 0x04 #267: _LET_ :: Tag _LET_ = 0x05 #268: _APP_ :: Tag _APP_ = 0x06 #269: _ANN_ :: Tag _ANN_ = 0x07 #270: _MAT_ :: Tag _MAT_ = 0x08 #271: _OPX_ :: Tag _OPX_ = 0x09 #272: _OPY_ :: Tag _OPY_ = 0x0A #273: _ERA_ :: Tag _ERA_ = 0x0B #274: _LAM_ :: Tag _LAM_ = 0x0C #275: _SUP_ :: Tag _SUP_ = 0x0D #276: _TYP_ :: Tag _TYP_ = 0x0E #277: _CTR_ :: Tag _CTR_ = 0x0F #278: _W32_ :: Tag _W32_ = 0x10 #279: _CHR_ :: Tag _CHR_ = 0x11 #280: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #281: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #282: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #283: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #284: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #285: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #286: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #287: //./Type.hs// #288: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #289: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #290: typedef _Atomic(Term) ATerm; #291: // Runtime Types // ------------- #292: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #293: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #294: // Constants // --------- #295: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #296: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #297: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #298: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #299: #define VOID 0x00000000000000 #300: // Heap // ---- #301: Loc get_len() { return *HVM.size; } #302: u64 get_itr() { return *HVM.itrs; } #303: u64 fresh() { return (*HVM.frsh)++; } #304: void set_len(Loc value) { *HVM.size = value; } #305: void set_itr(Loc value) { *HVM.itrs = value; } #306: // Terms // ------ #307: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #308: Tag term_tag(Term x) { return x & 0x7F; } #309: Tag term_bit(Term x) { return (x >> 7) & 1; } #310: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #311: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #312: Term term_set_bit(Term term) { return term | (1ULL << 7); } #313: // u12v2 // ----- #314: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #315: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #316: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #317: // Atomics // ------- #318: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #319: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #320: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #321: Term take(Loc loc) { return swap(loc, VOID); } #322: // Allocation // ---------- #323: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #324: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #325: // Stringification // --------------- #326: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #327: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #328: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #329: // Evaluation // ---------- #330: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #336: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #337: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #338: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #339: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #340: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #341: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #342: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #343: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #344: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #345: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #346: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #347: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #348: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #349: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #350: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #351: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #352: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #353: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #354: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #355: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #356: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #357: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #358: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #359: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #360: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #361: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #362: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #363: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #364: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #365: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #366: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #367: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #368: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #369: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #370: // Primitives // ---------- #371: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #372: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #373: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #374: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #375: // Runtime Memory // -------------- #376: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #377: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #378: State* hvm_get_state() { return &HVM; } #379: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #380: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #381: -- //./Type.hs// -- //./Inject.hs// #382: module HVML.Extract where #383: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #384: import Debug.Trace #385: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #386: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #387: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #388: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #389: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #390: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #391: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #392: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #393: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #394: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #395: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #396: -- Lifting Dups -- ------------ #397: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #398: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #399: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #400: module HVML.Equal where #401: import Control.Monad (liftM2) import HVML.Type import HVML.Show #402: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #403: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #404: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #405: -- //./Type.hs// #406: module HVML.Inject where #407: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #408: type InjectM a = StateT InjectState HVM a #409: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #410: emptyState :: InjectState emptyState = InjectState Map.empty [] #411: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #412: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #413: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #414: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #415: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #416: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #417: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #418: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #419: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #420: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #421: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #422: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #423: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #424: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #425: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #426: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 0) else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do collapseDupsAt state reduceAt book (loc + 1) else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Simple Queue -- ------------ -- Allows pushing to an end, and popping from another. -- Simple purely functional implementation. -- Includes sqPop and sqPut. #49: data SQ a = SQ [a] [a] #50: sqPop :: SQ a -> Maybe (a, SQ a) sqPop (SQ [] []) = Nothing sqPop (SQ [] ys) = sqPop (SQ (reverse ys) []) sqPop (SQ (x:xs) ys) = Just (x, SQ xs ys) #51: sqPut :: a -> SQ a -> SQ a sqPut x (SQ xs ys) = SQ xs (x:ys) #52: -- Flattener -- --------- #53: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #54: flattenBFS :: Collapse a -> [a] flattenBFS term = go term (SQ [] [] :: SQ (Collapse a)) where go (CSup k a b) sq = go CEra (sqPut b $ sqPut a $ sq) go (CVal x) sq = x : go CEra sq go CEra sq = case sqPop sq of Just (v,sq) -> go v sq Nothing -> [] #55: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #56: flatten :: Collapse a -> [a] flatten = flattenBFS #57: -- Flat Collapser -- -------------- #58: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #59: -- //./Type.hs// #60: module HVML.Show where #61: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #62: -- Core Stringification -- -------------------- #63: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #64: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #65: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #66: -- Runtime Stringification -- ----------------------- #67: tagToString :: Tag -> String tagToString t = show (tagT t) #68: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #69: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #70: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #71: -- Pretty Printers -- --------------- #72: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #73: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #74: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #75: -- Dumping -- ------- #76: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #77: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #78: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #79: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #80: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #81: -- //./Type.hs// #82: module HVML.Parse where #83: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #84: -- Core Parsers -- ------------ #85: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #86: type ParserM = Parsec String ParserState #87: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #88: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #89: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #90: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" skip next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #91: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #92: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #93: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #94: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #95: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #96: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #97: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #98: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #99: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #100: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #101: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #102: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #103: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #104: -- Helper Parsers -- -------------- #105: consume :: String -> ParserM String consume str = skip >> string str #106: closeWith :: String -> ParserM () closeWith str = try $ do skip notFollowedBy (string str) #107: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #108: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #109: -- Adjusting -- --------- #110: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #111: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #112: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #113: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #114: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #115: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #116: -- Errors -- ------ #117: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #118: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #119: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #120: module HVML.Reduce where #121: import Control.Monad (when, forM, forM_) import Data.Word import HVML.Collapse import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #122: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #123: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #124: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #125: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #126: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) -- msgs <- doCollapseFlatAt (const got) book (loc + 0) -- forM_ msgs $ \msg -> do -- putStrLn $ coreToString msg let ret = termNew _W32_ 0 0 set host ret return ret #127: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #128: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #129: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #130: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #131: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #132: -- //./Type.hs// -- //./Inject.hs// #133: module HVML.Compile where #134: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #135: import Debug.Trace #136: -- Compilation -- ----------- #137: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #138: type Compile = State CompileState #139: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #140: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #141: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #142: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #143: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #144: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #145: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #146: -- Full Compiler -- ------------- #147: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #148: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #149: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #150: -- Fast Compiler -- ------------- #151: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #152: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #153: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #154: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #155: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #156: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #157: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #158: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #159: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #160: -- Type.hs: -- //./Type.hs// #161: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #162: module Main where #163: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #164: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #165: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #166: -- Main -- ---- #167: data RunMode = Normalize | Collapse | Search deriving Eq #168: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #169: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #170: -- CLI Commands -- ------------ #171: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #172: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #173: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #174: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #175: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #176: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #177: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #178: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #179: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #180: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #181: -- Prints total time end <- getCPUTime #182: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #183: -- Finalize hvmFree return $ Right () #184: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #185: module HVML.Type where #186: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #187: -- Core Types -- ---------- #188: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #189: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #190: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #191: type Func = ([String], Core) #192: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #193: -- Runtime Types -- ------------- #194: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #195: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #196: type HVM = IO #197: type ReduceAt = Book -> Loc -> HVM Term #198: -- C Functions -- ----------- #199: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #200: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #201: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #202: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #203: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #204: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #205: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #206: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #207: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #208: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #209: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #210: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #211: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #212: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #213: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #214: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #215: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #216: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #250: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #251: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #252: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #253: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #254: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #255: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #256: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #257: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #258: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #259: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #260: -- Constants -- --------- #261: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #262: _DP0_ :: Tag _DP0_ = 0x00 #263: _DP1_ :: Tag _DP1_ = 0x01 #264: _VAR_ :: Tag _VAR_ = 0x02 #265: _SUB_ :: Tag _SUB_ = 0x03 #266: _REF_ :: Tag _REF_ = 0x04 #267: _LET_ :: Tag _LET_ = 0x05 #268: _APP_ :: Tag _APP_ = 0x06 #269: _ANN_ :: Tag _ANN_ = 0x07 #270: _MAT_ :: Tag _MAT_ = 0x08 #271: _OPX_ :: Tag _OPX_ = 0x09 #272: _OPY_ :: Tag _OPY_ = 0x0A #273: _ERA_ :: Tag _ERA_ = 0x0B #274: _LAM_ :: Tag _LAM_ = 0x0C #275: _SUP_ :: Tag _SUP_ = 0x0D #276: _TYP_ :: Tag _TYP_ = 0x0E #277: _CTR_ :: Tag _CTR_ = 0x0F #278: _W32_ :: Tag _W32_ = 0x10 #279: _CHR_ :: Tag _CHR_ = 0x11 #280: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #281: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #282: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #283: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #284: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #285: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #286: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #287: //./Type.hs// #288: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #289: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #290: typedef _Atomic(Term) ATerm; #291: // Runtime Types // ------------- #292: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #293: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #294: // Constants // --------- #295: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #296: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #297: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #298: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #299: #define VOID 0x00000000000000 #300: // Heap // ---- #301: Loc get_len() { return *HVM.size; } #302: u64 get_itr() { return *HVM.itrs; } #303: u64 fresh() { return (*HVM.frsh)++; } #304: void set_len(Loc value) { *HVM.size = value; } #305: void set_itr(Loc value) { *HVM.itrs = value; } #306: // Terms // ------ #307: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #308: Tag term_tag(Term x) { return x & 0x7F; } #309: Tag term_bit(Term x) { return (x >> 7) & 1; } #310: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #311: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #312: Term term_set_bit(Term term) { return term | (1ULL << 7); } #313: // u12v2 // ----- #314: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #315: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #316: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #317: // Atomics // ------- #318: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #319: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #320: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #321: Term take(Loc loc) { return swap(loc, VOID); } #322: // Allocation // ---------- #323: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #324: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #325: // Stringification // --------------- #326: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #327: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #328: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #329: // Evaluation // ---------- #330: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #331: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #332: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #333: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #334: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #335: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #336: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #337: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #338: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #339: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #340: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #341: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #342: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #343: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #344: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #345: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #346: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #347: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #348: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #349: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #350: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #351: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #352: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #353: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #354: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #355: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #356: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #357: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #358: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #359: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #360: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #361: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #362: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #363: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #364: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #365: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #366: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #367: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #368: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #369: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #370: // Primitives // ---------- #371: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #372: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #373: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #374: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #375: // Runtime Memory // -------------- #376: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #377: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #378: State* hvm_get_state() { return &HVM; } #379: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #380: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #381: -- //./Type.hs// -- //./Inject.hs// #382: module HVML.Extract where #383: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #384: import Debug.Trace #385: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #386: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #387: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #388: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #389: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #390: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #391: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #392: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #393: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #394: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #395: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #396: -- Lifting Dups -- ------------ #397: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #398: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #399: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #400: module HVML.Equal where #401: import Control.Monad (liftM2) import HVML.Type import HVML.Show #402: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #403: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #404: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #405: -- //./Type.hs// #406: module HVML.Inject where #407: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #408: type InjectM a = StateT InjectState HVM a #409: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #410: emptyState :: InjectState emptyState = InjectState Map.empty [] #411: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #412: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #413: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #414: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #415: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #416: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #417: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #418: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #419: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #420: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #421: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #422: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #423: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #424: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #425: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #426: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

9a45eb451388317a4ead94d7eb7bb95b711de474

fix refactored collapser bug

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #6: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #7: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #8: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe id putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe id putI x)) (fromIntegral k) paths in CSup k lft rgt #9: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) _ -> CSup k x y #10: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #11: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #12: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #13: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #14: instance Applicative Collapse where pure = CVal (<*>) = ap #15: instance Monad Collapse where return = pure (>>=) = bind #16: -- Dup Collapser -- ------------- #17: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #18: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #19: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #20: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #21: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #22: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #23: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #24: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #25: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #26: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #27: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #29: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #30: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #31: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #32: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #33: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #35: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #36: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #37: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #38: -- Sup Collapser -- ------------- #39: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #40: -- Tree Collapser -- -------------- #41: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #42: -- Priority Queue -- -------------- #43: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #44: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #45: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #46: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #47: -- Flattener -- --------- #48: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #49: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #50: flatten :: Collapse a -> [a] flatten = flattenPQ #51: -- Flat Collapser -- -------------- #52: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #53: -- //./Type.hs// #54: module HVML.Show where #55: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #56: -- Core Stringification -- -------------------- #57: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #58: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #59: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #60: -- Runtime Stringification -- ----------------------- #61: tagToString :: Tag -> String tagToString t = show (tagT t) #62: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #63: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #64: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #65: -- Pretty Printers -- --------------- #66: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #67: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #68: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #69: -- Dumping -- ------- #70: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #71: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #72: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #73: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #74: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #75: -- //./Type.hs// #76: module HVML.Parse where #77: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #78: -- Core Parsers -- ------------ #79: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #80: type ParserM = Parsec String ParserState #81: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #82: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #83: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #84: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #85: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #86: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #87: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #88: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #89: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #90: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #91: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #92: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #93: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #94: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #95: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #96: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #97: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #98: -- Helper Parsers -- -------------- #99: consume :: String -> ParserM String consume str = spaces >> string str #100: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #101: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #102: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #103: -- Adjusting -- --------- #104: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #105: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #106: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #107: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #108: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #109: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #110: -- Errors -- ------ #111: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #112: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #113: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #114: module HVML.Reduce where #115: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #116: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #117: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #118: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #119: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #120: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) let ret = termNew _W32_ 0 0 set host ret return ret #121: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #122: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #123: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #124: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #125: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #126: -- //./Type.hs// -- //./Inject.hs// #127: module HVML.Compile where #128: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #129: import Debug.Trace #130: -- Compilation -- ----------- #131: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #132: type Compile = State CompileState #133: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #134: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #135: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #136: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #137: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #138: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #139: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #140: -- Full Compiler -- ------------- #141: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #142: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #143: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #144: -- Fast Compiler -- ------------- #145: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #146: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #147: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #148: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #149: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #150: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #151: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #153: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #154: -- Type.hs: -- //./Type.hs// #155: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #156: module Main where #157: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #158: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #159: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #160: -- Main -- ---- #161: data RunMode = Normalize | Collapse | Search deriving Eq #162: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #163: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #164: -- CLI Commands -- ------------ #165: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #166: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #167: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #168: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #169: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #170: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #171: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #172: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #173: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #174: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #175: -- Prints total time end <- getCPUTime #176: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #177: -- Finalize hvmFree return $ Right () #178: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #179: module HVML.Type where #180: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #181: -- Core Types -- ---------- #182: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #183: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #184: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #185: type Func = ([String], Core) #186: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #187: -- Runtime Types -- ------------- #188: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #189: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #190: type HVM = IO #191: type ReduceAt = Book -> Loc -> HVM Term #192: -- C Functions -- ----------- #193: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #194: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #195: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #196: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #197: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #198: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #199: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #200: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #201: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #202: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #203: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #204: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #205: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #206: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #207: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #208: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #209: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #210: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #249: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #250: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #251: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #252: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #253: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #254: -- Constants -- --------- #255: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #256: _DP0_ :: Tag _DP0_ = 0x00 #257: _DP1_ :: Tag _DP1_ = 0x01 #258: _VAR_ :: Tag _VAR_ = 0x02 #259: _SUB_ :: Tag _SUB_ = 0x03 #260: _REF_ :: Tag _REF_ = 0x04 #261: _LET_ :: Tag _LET_ = 0x05 #262: _APP_ :: Tag _APP_ = 0x06 #263: _ANN_ :: Tag _ANN_ = 0x07 #264: _MAT_ :: Tag _MAT_ = 0x08 #265: _OPX_ :: Tag _OPX_ = 0x09 #266: _OPY_ :: Tag _OPY_ = 0x0A #267: _ERA_ :: Tag _ERA_ = 0x0B #268: _LAM_ :: Tag _LAM_ = 0x0C #269: _SUP_ :: Tag _SUP_ = 0x0D #270: _TYP_ :: Tag _TYP_ = 0x0E #271: _CTR_ :: Tag _CTR_ = 0x0F #272: _W32_ :: Tag _W32_ = 0x10 #273: _CHR_ :: Tag _CHR_ = 0x11 #274: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #275: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #276: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #277: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #278: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #279: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #280: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #281: //./Type.hs// #282: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #283: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #284: typedef _Atomic(Term) ATerm; #285: // Runtime Types // ------------- #286: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #287: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #288: // Constants // --------- #289: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #290: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #291: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #292: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #293: #define VOID 0x00000000000000 #294: // Heap // ---- #295: Loc get_len() { return *HVM.size; } #296: u64 get_itr() { return *HVM.itrs; } #297: u64 fresh() { return (*HVM.frsh)++; } #298: void set_len(Loc value) { *HVM.size = value; } #299: void set_itr(Loc value) { *HVM.itrs = value; } #300: // Terms // ------ #301: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #302: Tag term_tag(Term x) { return x & 0x7F; } #303: Tag term_bit(Term x) { return (x >> 7) & 1; } #304: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #305: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #306: Term term_set_bit(Term term) { return term | (1ULL << 7); } #307: // u12v2 // ----- #308: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #309: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #310: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #311: // Atomics // ------- #312: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #313: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #314: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #315: Term take(Loc loc) { return swap(loc, VOID); } #316: // Allocation // ---------- #317: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #318: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #319: // Stringification // --------------- #320: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #321: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #322: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #323: // Evaluation // ---------- #324: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #325: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #326: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #327: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #328: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #329: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #330: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #331: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #332: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #333: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #334: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #335: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #336: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #337: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #338: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #339: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #340: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #341: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #342: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #343: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #344: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #345: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #346: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #347: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #348: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #349: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #350: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #351: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #352: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #353: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #354: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #355: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #356: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #357: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #358: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #359: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #360: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #361: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #362: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #363: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #364: // Primitives // ---------- #365: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #366: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #367: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #368: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #369: // Runtime Memory // -------------- #370: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #371: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #372: State* hvm_get_state() { return &HVM; } #373: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #374: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #375: -- //./Type.hs// -- //./Inject.hs// #376: module HVML.Extract where #377: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #378: import Debug.Trace #379: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #380: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #381: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #382: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #383: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #384: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #385: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #386: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #387: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #388: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #389: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #390: -- Lifting Dups -- ------------ #391: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #392: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #393: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #394: module HVML.Equal where #395: import Control.Monad (liftM2) import HVML.Type import HVML.Show #396: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #397: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #398: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #399: -- //./Type.hs// #400: module HVML.Inject where #401: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #402: type InjectM a = StateT InjectState HVM a #403: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #404: emptyState :: InjectState emptyState = InjectState Map.empty [] #405: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #406: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #407: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #408: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #409: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #410: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #411: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #412: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #413: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #414: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #415: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #416: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #417: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #418: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #419: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #420: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: import Debug.Trace #6: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #7: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #8: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #9: bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe (putO id) putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe (putI id) putI x)) (fromIntegral k) paths in CSup k lft rgt #10: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) Just E -> CSup k x y Nothing -> CSup k x y #11: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #12: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #13: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #14: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #15: instance Applicative Collapse where pure = CVal (<*>) = ap #16: instance Monad Collapse where return = pure (>>=) = bind #17: -- Dup Collapser -- ------------- #18: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #19: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #20: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #21: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #22: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #23: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #24: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #25: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #26: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #27: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #29: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #30: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #31: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #32: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #33: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #35: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #36: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #37: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #38: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #39: -- Sup Collapser -- ------------- #40: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #41: -- Tree Collapser -- -------------- #42: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #43: -- Priority Queue -- -------------- #44: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #45: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #46: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #47: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #48: -- Flattener -- --------- #49: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #50: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #51: flatten :: Collapse a -> [a] flatten = flattenPQ #52: -- Flat Collapser -- -------------- #53: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #54: -- //./Type.hs// #55: module HVML.Show where #56: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #57: -- Core Stringification -- -------------------- #58: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #59: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #60: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #61: -- Runtime Stringification -- ----------------------- #62: tagToString :: Tag -> String tagToString t = show (tagT t) #63: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #64: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #65: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #66: -- Pretty Printers -- --------------- #67: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #68: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #69: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #70: -- Dumping -- ------- #71: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #72: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #73: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #74: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #75: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #76: -- //./Type.hs// #77: module HVML.Parse where #78: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #79: -- Core Parsers -- ------------ #80: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #81: type ParserM = Parsec String ParserState #82: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #83: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #84: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #85: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #86: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #87: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #88: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #89: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #90: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #91: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #92: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #93: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #94: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #95: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #96: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #97: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #98: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #99: -- Helper Parsers -- -------------- #100: consume :: String -> ParserM String consume str = spaces >> string str #101: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #102: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #103: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #104: -- Adjusting -- --------- #105: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #106: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #107: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #108: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #109: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #110: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #111: -- Errors -- ------ #112: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #113: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #114: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #115: module HVML.Reduce where #116: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #117: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #118: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #119: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #120: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #121: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) let ret = termNew _W32_ 0 0 set host ret return ret #122: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #123: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #124: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #125: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #126: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #127: -- //./Type.hs// -- //./Inject.hs// #128: module HVML.Compile where #129: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #130: import Debug.Trace #131: -- Compilation -- ----------- #132: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #133: type Compile = State CompileState #134: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #135: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #136: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #137: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #138: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #139: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #140: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #141: -- Full Compiler -- ------------- #142: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #143: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #144: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Fast Compiler -- ------------- #146: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #147: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #148: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #149: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #150: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #151: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #152: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #153: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #154: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #155: -- Type.hs: -- //./Type.hs// #156: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #157: module Main where #158: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #159: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #160: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #161: -- Main -- ---- #162: data RunMode = Normalize | Collapse | Search deriving Eq #163: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #164: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #165: -- CLI Commands -- ------------ #166: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #167: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #168: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #169: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #170: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #171: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #172: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #173: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #174: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #175: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #176: -- Prints total time end <- getCPUTime #177: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #178: -- Finalize hvmFree return $ Right () #179: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #180: module HVML.Type where #181: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #182: -- Core Types -- ---------- #183: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #184: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #185: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #186: type Func = ([String], Core) #187: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #188: -- Runtime Types -- ------------- #189: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #190: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #191: type HVM = IO #192: type ReduceAt = Book -> Loc -> HVM Term #193: -- C Functions -- ----------- #194: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #195: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #196: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #197: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #198: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #199: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #200: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #201: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #202: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #203: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #204: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #205: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #206: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #207: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #208: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #209: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #210: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #211: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #249: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #250: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #251: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #252: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #253: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #254: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #255: -- Constants -- --------- #256: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #257: _DP0_ :: Tag _DP0_ = 0x00 #258: _DP1_ :: Tag _DP1_ = 0x01 #259: _VAR_ :: Tag _VAR_ = 0x02 #260: _SUB_ :: Tag _SUB_ = 0x03 #261: _REF_ :: Tag _REF_ = 0x04 #262: _LET_ :: Tag _LET_ = 0x05 #263: _APP_ :: Tag _APP_ = 0x06 #264: _ANN_ :: Tag _ANN_ = 0x07 #265: _MAT_ :: Tag _MAT_ = 0x08 #266: _OPX_ :: Tag _OPX_ = 0x09 #267: _OPY_ :: Tag _OPY_ = 0x0A #268: _ERA_ :: Tag _ERA_ = 0x0B #269: _LAM_ :: Tag _LAM_ = 0x0C #270: _SUP_ :: Tag _SUP_ = 0x0D #271: _TYP_ :: Tag _TYP_ = 0x0E #272: _CTR_ :: Tag _CTR_ = 0x0F #273: _W32_ :: Tag _W32_ = 0x10 #274: _CHR_ :: Tag _CHR_ = 0x11 #275: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #276: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #277: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #278: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #279: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #280: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #281: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #282: //./Type.hs// #283: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #284: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #285: typedef _Atomic(Term) ATerm; #286: // Runtime Types // ------------- #287: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #288: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #289: // Constants // --------- #290: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #291: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #292: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #293: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #294: #define VOID 0x00000000000000 #295: // Heap // ---- #296: Loc get_len() { return *HVM.size; } #297: u64 get_itr() { return *HVM.itrs; } #298: u64 fresh() { return (*HVM.frsh)++; } #299: void set_len(Loc value) { *HVM.size = value; } #300: void set_itr(Loc value) { *HVM.itrs = value; } #301: // Terms // ------ #302: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #303: Tag term_tag(Term x) { return x & 0x7F; } #304: Tag term_bit(Term x) { return (x >> 7) & 1; } #305: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #306: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #307: Term term_set_bit(Term term) { return term | (1ULL << 7); } #308: // u12v2 // ----- #309: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #310: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #311: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #312: // Atomics // ------- #313: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #314: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #315: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #316: Term take(Loc loc) { return swap(loc, VOID); } #317: // Allocation // ---------- #318: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #319: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #320: // Stringification // --------------- #321: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #322: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #323: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #324: // Evaluation // ---------- #325: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #326: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #327: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #328: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #329: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #330: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #331: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #332: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #333: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #334: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #335: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #336: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #337: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #338: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #339: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #340: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #341: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #342: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #343: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #344: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #345: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #346: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #347: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #348: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #349: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #350: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #351: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #352: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #353: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #354: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #355: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #356: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #357: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #358: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #359: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #360: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #361: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #362: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #363: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #364: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #365: // Primitives // ---------- #366: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #367: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #368: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #369: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #370: // Runtime Memory // -------------- #371: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #372: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #373: State* hvm_get_state() { return &HVM; } #374: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #375: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #376: -- //./Type.hs// -- //./Inject.hs// #377: module HVML.Extract where #378: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #379: import Debug.Trace #380: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #381: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #382: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #383: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #384: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #385: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #386: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #387: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #388: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #389: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #390: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #391: -- Lifting Dups -- ------------ #392: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #393: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #394: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #395: module HVML.Equal where #396: import Control.Monad (liftM2) import HVML.Type import HVML.Show #397: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #398: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #399: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #400: -- //./Type.hs// #401: module HVML.Inject where #402: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #403: type InjectM a = StateT InjectState HVM a #404: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #405: emptyState :: InjectState emptyState = InjectState Map.empty [] #406: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #407: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #408: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #409: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #410: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #411: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #412: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #413: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #414: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #415: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #416: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #417: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #418: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #419: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #420: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #421: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

4907cd757b0de633af54d03e55c6983c98c29494

dyn sup/dup syntax; auto sup/dup syntax; faster collapser; allow cloning unboxed var; rename exampels now '&' can be part of a variable name. variables that start with '&' are assumed to be unboxed (i.e., numbers, nullary constructors, era) and, as such, can be used multiple times. now we can use '&a{x y}' and '&a{x y}=v body' and to create a dyn sup/dup with '&a' label, as a syntax sugar for '@SUP(&a x y)' and '@DUP(&a v λxλy(body))' now, when we omit the label of a sup/dup node, HVML will generate a static fresh name for you. ex: '&{1 2}' becomes '&8388608{1 2}' the collapser has been fixed to use IntMap instead of lists, so that large labels don't make it slow anymore all the examples on book/ have been renamed and cleaned up

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #6: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #7: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #8: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #9: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #10: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #11: instance Applicative Collapse where pure = CVal (<*>) = ap #12: instance Monad Collapse where return = pure (>>=) = bind #13: -- Dup Collapser -- ------------- #14: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #15: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #21: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #22: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #23: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #25: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #26: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #33: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #34: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #35: -- Sup Collapser -- ------------- #36: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #37: -- Tree Collapser -- -------------- #38: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #39: -- Priority Queue -- -------------- #40: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #41: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #42: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #43: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #44: -- Flattener -- --------- #45: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #46: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #47: flatten :: Collapse a -> [a] flatten = flattenDFS #48: -- Flat Collapser -- -------------- #49: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #50: -- //./Type.hs// #51: module HVML.Show where #52: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #53: -- Core Stringification -- -------------------- #54: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #55: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #56: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #57: -- Runtime Stringification -- ----------------------- #58: tagToString :: Tag -> String tagToString t = show (tagT t) #59: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #60: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #61: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #62: -- Pretty Printers -- --------------- #63: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #64: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #65: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #66: -- Dumping -- ------- #67: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #68: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #69: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #70: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #71: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #72: -- //./Type.hs// #73: module HVML.Parse where #74: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #75: -- Core Parsers -- ------------ #76: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #77: type ParserM = Parsec String ParserState #78: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #79: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #80: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #81: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #82: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #83: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #84: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #85: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #86: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #87: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #88: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #89: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #90: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #91: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #92: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #93: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #94: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #95: -- Helper Parsers -- -------------- #96: consume :: String -> ParserM String consume str = spaces >> string str #97: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #98: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #99: -- Adjusting -- --------- #100: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #101: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #102: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #103: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #104: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #105: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #106: -- Errors -- ------ #107: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #108: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #109: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #110: module HVML.Reduce where #111: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #112: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #113: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #115: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #116: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) let ret = termNew _W32_ 0 0 set host ret return ret #117: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #118: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #119: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #120: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #121: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #122: -- //./Type.hs// -- //./Inject.hs// #123: module HVML.Compile where #124: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #125: import Debug.Trace #126: -- Compilation -- ----------- #127: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #128: type Compile = State CompileState #129: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #130: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #131: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #132: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #133: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #134: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #135: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #136: -- Full Compiler -- ------------- #137: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #138: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #139: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #140: -- Fast Compiler -- ------------- #141: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #142: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #143: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #144: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #145: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #146: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #147: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #148: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #149: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #150: -- Type.hs: -- //./Type.hs// #151: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #152: module Main where #153: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #154: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #155: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #156: -- Main -- ---- #157: data RunMode = Normalize | Collapse | Search deriving Eq #158: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #159: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #160: -- CLI Commands -- ------------ #161: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #162: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #163: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #164: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #165: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #166: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #167: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #168: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #169: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #170: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #171: -- Prints total time end <- getCPUTime #172: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #173: -- Finalize hvmFree return $ Right () #174: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #175: module HVML.Type where #176: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #177: -- Core Types -- ---------- #178: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #179: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #180: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #181: type Func = ([String], Core) #182: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #183: -- Runtime Types -- ------------- #184: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #185: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #186: type HVM = IO #187: type ReduceAt = Book -> Loc -> HVM Term #188: -- C Functions -- ----------- #189: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #190: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #191: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #192: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #193: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #194: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #195: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #196: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #197: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #198: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #200: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #201: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #202: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #203: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #204: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #205: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #206: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #245: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #246: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #247: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #248: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #249: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #250: -- Constants -- --------- #251: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #252: _DP0_ :: Tag _DP0_ = 0x00 #253: _DP1_ :: Tag _DP1_ = 0x01 #254: _VAR_ :: Tag _VAR_ = 0x02 #255: _SUB_ :: Tag _SUB_ = 0x03 #256: _REF_ :: Tag _REF_ = 0x04 #257: _LET_ :: Tag _LET_ = 0x05 #258: _APP_ :: Tag _APP_ = 0x06 #259: _ANN_ :: Tag _ANN_ = 0x07 #260: _MAT_ :: Tag _MAT_ = 0x08 #261: _OPX_ :: Tag _OPX_ = 0x09 #262: _OPY_ :: Tag _OPY_ = 0x0A #263: _ERA_ :: Tag _ERA_ = 0x0B #264: _LAM_ :: Tag _LAM_ = 0x0C #265: _SUP_ :: Tag _SUP_ = 0x0D #266: _TYP_ :: Tag _TYP_ = 0x0E #267: _CTR_ :: Tag _CTR_ = 0x0F #268: _W32_ :: Tag _W32_ = 0x10 #269: _CHR_ :: Tag _CHR_ = 0x11 #270: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #271: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #272: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #273: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #274: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #275: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #276: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #277: //./Type.hs// #278: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #279: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #280: typedef _Atomic(Term) ATerm; #281: // Runtime Types // ------------- #282: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #283: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #284: // Constants // --------- #285: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #286: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #287: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #288: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #289: #define VOID 0x00000000000000 #290: // Heap // ---- #291: Loc get_len() { return *HVM.size; } #292: u64 get_itr() { return *HVM.itrs; } #293: u64 fresh() { return (*HVM.frsh)++; } #294: void set_len(Loc value) { *HVM.size = value; } #295: void set_itr(Loc value) { *HVM.itrs = value; } #296: // Terms // ------ #297: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #298: Tag term_tag(Term x) { return x & 0x7F; } #299: Tag term_bit(Term x) { return (x >> 7) & 1; } #300: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #301: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #302: Term term_set_bit(Term term) { return term | (1ULL << 7); } #303: // u12v2 // ----- #304: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #305: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #306: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #307: // Atomics // ------- #308: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #309: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #310: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #311: Term take(Loc loc) { return swap(loc, VOID); } #312: // Allocation // ---------- #313: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #314: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #315: // Stringification // --------------- #316: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #317: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #318: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #319: // Evaluation // ---------- #320: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #321: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #322: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #323: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #324: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #325: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #326: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #327: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #328: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #329: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #330: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #331: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #332: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #333: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #334: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #335: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #336: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #337: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #338: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #339: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #340: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #341: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #342: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #343: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #344: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #345: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #346: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #347: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #348: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #349: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #350: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #351: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #352: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #353: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #354: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #355: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #356: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #357: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #358: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #359: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #360: // Primitives // ---------- #361: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #362: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #363: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #364: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #365: // Runtime Memory // -------------- #366: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #367: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #368: State* hvm_get_state() { return &HVM; } #369: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #370: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #371: -- //./Type.hs// -- //./Inject.hs// #372: module HVML.Extract where #373: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #374: import Debug.Trace #375: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #376: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #377: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #378: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #379: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #380: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #381: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #382: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #383: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #384: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #385: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #386: -- Lifting Dups -- ------------ #387: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #388: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #389: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #390: module HVML.Equal where #391: import Control.Monad (liftM2) import HVML.Type import HVML.Show #392: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #393: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #394: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #395: -- //./Type.hs// #396: module HVML.Inject where #397: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #398: type InjectM a = StateT InjectState HVM a #399: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #400: emptyState :: InjectState emptyState = InjectState Map.empty [] #401: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #402: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #403: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #404: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #405: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #406: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #407: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #408: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #409: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #410: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #411: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #412: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #413: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #414: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #415: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #416: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #6: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #7: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #8: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind k f = fork k IM.empty where -- fork :: Collapse a -> IntMap (Bin -> Bin) -> Collapse b fork CEra paths = CEra fork (CVal v) paths = pass (f v) (IM.map (\x -> x E) paths) fork (CSup k x y) paths = let lft = fork x $ IM.alter (\x -> Just (maybe id putO x)) (fromIntegral k) paths in let rgt = fork y $ IM.alter (\x -> Just (maybe id putI x)) (fromIntegral k) paths in CSup k lft rgt #9: -- pass :: Collapse b -> IntMap Bin -> Collapse b pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case IM.lookup (fromIntegral k) paths of Just (O p) -> pass x (IM.insert (fromIntegral k) p paths) Just (I p) -> pass y (IM.insert (fromIntegral k) p paths) _ -> CSup k x y #10: -- putO :: (Bin -> Bin) -> (Bin -> Bin) putO bs = \x -> bs (O x) #11: -- putI :: (Bin -> Bin) -> (Bin -> Bin) putI bs = \x -> bs (I x) #12: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #13: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #14: instance Applicative Collapse where pure = CVal (<*>) = ap #15: instance Monad Collapse where return = pure (>>=) = bind #16: -- Dup Collapser -- ------------- #17: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #18: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #19: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #20: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #21: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #22: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #23: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #24: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #25: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #26: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #27: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #28: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #29: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #30: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #31: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #32: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #33: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #34: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #35: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #36: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #37: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #38: -- Sup Collapser -- ------------- #39: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #40: -- Tree Collapser -- -------------- #41: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #42: -- Priority Queue -- -------------- #43: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #44: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #45: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #46: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #47: -- Flattener -- --------- #48: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #49: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #50: flatten :: Collapse a -> [a] flatten = flattenPQ #51: -- Flat Collapser -- -------------- #52: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #53: -- //./Type.hs// #54: module HVML.Show where #55: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #56: -- Core Stringification -- -------------------- #57: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #58: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #59: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #60: -- Runtime Stringification -- ----------------------- #61: tagToString :: Tag -> String tagToString t = show (tagT t) #62: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #63: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #64: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #65: -- Pretty Printers -- --------------- #66: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #67: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #68: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #69: -- Dumping -- ------- #70: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #71: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #72: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #73: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #74: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #75: -- //./Type.hs// #76: module HVML.Parse where #77: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #78: -- Core Parsers -- ------------ #79: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 , freshLabel :: Word64 } #80: type ParserM = Parsec String ParserState #81: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName1 bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" name <- parseName next <- optionMaybe $ try $ char '{' case next of Just _ -> do tm0 <- parseCore tm1 <- parseCore consume "}" if null name then do num <- genFreshLabel return $ Sup num tm0 tm1 else case reads name of [(num :: Word64, "")] -> do return $ Sup num tm0 tm1 otherwise -> do return $ Ref "SUP" _SUP_F_ [Var ("&" ++ name), tm0, tm1] Nothing -> do return $ Var ("&" ++ name) '%' -> do consume "%" nam <- parseName1 typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" nam <- parseName consume "{" dp0 <- parseName1 dp1 <- parseName1 consume "}" consume "=" val <- parseCore bod <- parseCore if null nam then do num <- genFreshLabel return $ Dup num dp0 dp1 val bod else case reads nam of [(num :: Word64, "")] -> do return $ Dup num dp0 dp1 val bod otherwise -> do return $ Ref "DUP" _DUP_F_ [Var ("&" ++ nam), val, Lam dp0 (Lam dp1 bod)] '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName1 consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName1 consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName1 case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #82: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName1 args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #83: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName1 cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #84: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName1 val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName1 fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName1 consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName1 case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #85: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #86: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #87: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #88: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #89: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #90: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$' <|> char '&') #91: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_' <|> char '$' <|> char '&') #92: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #93: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #94: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #95: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #96: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty 0) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #97: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty 0) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #98: -- Helper Parsers -- -------------- #99: consume :: String -> ParserM String consume str = spaces >> string str #100: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #101: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #102: genFreshLabel :: ParserM Word64 genFreshLabel = do st <- getState let lbl = freshLabel st putState st { freshLabel = lbl + 1 } return $ lbl + 0x800000 #103: -- Adjusting -- --------- #104: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #105: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #106: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #107: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #108: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #109: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #110: -- Errors -- ------ #111: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #112: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #113: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #114: module HVML.Reduce where #115: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #116: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #117: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #118: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #119: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #120: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) let ret = termNew _W32_ 0 0 set host ret return ret #121: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #122: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #123: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #124: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #125: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #126: -- //./Type.hs// -- //./Inject.hs// #127: module HVML.Compile where #128: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #129: import Debug.Trace #130: -- Compilation -- ----------- #131: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #132: type Compile = State CompileState #133: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #134: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #135: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #136: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #137: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #138: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #139: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #140: -- Full Compiler -- ------------- #141: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #142: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #143: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #144: -- Fast Compiler -- ------------- #145: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #146: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #147: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #148: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #149: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #150: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #151: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #152: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #153: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #154: -- Type.hs: -- //./Type.hs// #155: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #156: module Main where #157: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #158: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #159: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #160: -- Main -- ---- #161: data RunMode = Normalize | Collapse | Search deriving Eq #162: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #163: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #164: -- CLI Commands -- ------------ #165: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #166: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #167: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #168: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #169: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #170: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #171: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #172: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #173: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #174: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #175: -- Prints total time end <- getCPUTime #176: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #177: -- Finalize hvmFree return $ Right () #178: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #179: module HVML.Type where #180: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #181: -- Core Types -- ---------- #182: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #183: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #184: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #185: type Func = ([String], Core) #186: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #187: -- Runtime Types -- ------------- #188: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #189: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #190: type HVM = IO #191: type ReduceAt = Book -> Loc -> HVM Term #192: -- C Functions -- ----------- #193: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #194: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #195: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #196: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #197: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #198: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #199: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #200: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #201: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #202: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #203: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #204: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #205: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #206: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #207: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #208: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #209: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #210: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #245: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #246: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #247: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #248: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #249: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #250: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #251: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #252: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #253: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #254: -- Constants -- --------- #255: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #256: _DP0_ :: Tag _DP0_ = 0x00 #257: _DP1_ :: Tag _DP1_ = 0x01 #258: _VAR_ :: Tag _VAR_ = 0x02 #259: _SUB_ :: Tag _SUB_ = 0x03 #260: _REF_ :: Tag _REF_ = 0x04 #261: _LET_ :: Tag _LET_ = 0x05 #262: _APP_ :: Tag _APP_ = 0x06 #263: _ANN_ :: Tag _ANN_ = 0x07 #264: _MAT_ :: Tag _MAT_ = 0x08 #265: _OPX_ :: Tag _OPX_ = 0x09 #266: _OPY_ :: Tag _OPY_ = 0x0A #267: _ERA_ :: Tag _ERA_ = 0x0B #268: _LAM_ :: Tag _LAM_ = 0x0C #269: _SUP_ :: Tag _SUP_ = 0x0D #270: _TYP_ :: Tag _TYP_ = 0x0E #271: _CTR_ :: Tag _CTR_ = 0x0F #272: _W32_ :: Tag _W32_ = 0x10 #273: _CHR_ :: Tag _CHR_ = 0x11 #274: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #275: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #276: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #277: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #278: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #279: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #280: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #281: //./Type.hs// #282: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #283: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #284: typedef _Atomic(Term) ATerm; #285: // Runtime Types // ------------- #286: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #287: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #288: // Constants // --------- #289: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #290: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #291: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #292: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #293: #define VOID 0x00000000000000 #294: // Heap // ---- #295: Loc get_len() { return *HVM.size; } #296: u64 get_itr() { return *HVM.itrs; } #297: u64 fresh() { return (*HVM.frsh)++; } #298: void set_len(Loc value) { *HVM.size = value; } #299: void set_itr(Loc value) { *HVM.itrs = value; } #300: // Terms // ------ #301: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #302: Tag term_tag(Term x) { return x & 0x7F; } #303: Tag term_bit(Term x) { return (x >> 7) & 1; } #304: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #305: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #306: Term term_set_bit(Term term) { return term | (1ULL << 7); } #307: // u12v2 // ----- #308: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #309: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #310: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #311: // Atomics // ------- #312: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #313: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #314: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #315: Term take(Loc loc) { return swap(loc, VOID); } #316: // Allocation // ---------- #317: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #318: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #319: // Stringification // --------------- #320: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #321: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #322: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #323: // Evaluation // ---------- #324: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #325: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #326: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #327: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #328: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #329: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #330: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #331: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #332: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #333: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #334: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #335: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #336: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #337: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #338: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #339: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #340: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #341: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #342: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #343: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #344: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #345: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #346: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #347: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #348: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #349: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #350: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #351: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #352: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #353: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #354: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #355: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #356: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #357: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #358: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #359: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #360: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #361: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #362: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #363: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #364: // Primitives // ---------- #365: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #366: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #367: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #368: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #369: // Runtime Memory // -------------- #370: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #371: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #372: State* hvm_get_state() { return &HVM; } #373: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #374: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #375: -- //./Type.hs// -- //./Inject.hs// #376: module HVML.Extract where #377: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #378: import Debug.Trace #379: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #380: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #381: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #382: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #383: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #384: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #385: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #386: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #387: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #388: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #389: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #390: -- Lifting Dups -- ------------ #391: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #392: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #393: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #394: module HVML.Equal where #395: import Control.Monad (liftM2) import HVML.Type import HVML.Show #396: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #397: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #398: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #399: -- //./Type.hs// #400: module HVML.Inject where #401: import Control.Monad (foldM, when, forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #402: type InjectM a = StateT InjectState HVM a #403: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #404: emptyState :: InjectState emptyState = InjectState Map.empty [] #405: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #406: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term when (head nam /= '&') $ do modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #407: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #408: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #409: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #410: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #411: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #412: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #413: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #414: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #415: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #416: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #417: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #418: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #419: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #420: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term if (head name /= '&') then do return $ Map.delete name m else do return $ m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

a6c27664568fd6db122796ea1cd4d17199ffa802

dependently typed λ-term superposer

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// -- //./Inject.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #113: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> error $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab #115: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #116: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #117: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #118: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #119: -- //./Type.hs// -- //./Inject.hs// #120: module HVML.Compile where #121: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #122: import Debug.Trace #123: -- Compilation -- ----------- #124: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #125: type Compile = State CompileState #126: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #127: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #128: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #129: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #130: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #131: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #132: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #133: -- Full Compiler -- ------------- #134: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #135: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #136: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #137: -- Fast Compiler -- ------------- #138: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #139: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #140: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #141: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #142: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #143: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #144: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #146: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #147: -- Type.hs: -- //./Type.hs// #148: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #149: module Main where #150: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #151: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #152: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #153: -- Main -- ---- #154: data RunMode = Normalize | Collapse | Search deriving Eq #155: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #156: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #157: -- CLI Commands -- ------------ #158: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #159: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #160: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #161: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #162: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #163: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #164: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #165: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #166: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #167: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #168: -- Prints total time end <- getCPUTime #169: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #170: -- Finalize hvmFree return $ Right () #171: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #172: module HVML.Type where #173: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #174: -- Core Types -- ---------- #175: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #176: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #177: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #178: type Func = ([String], Core) #179: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #180: -- Runtime Types -- ------------- #181: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #182: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #183: type HVM = IO #184: type ReduceAt = Book -> Loc -> HVM Term #185: -- C Functions -- ----------- #186: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #187: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #188: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #189: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #190: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #191: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #192: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #193: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #194: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #195: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #196: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #197: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #198: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #200: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #201: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #202: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #241: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #242: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #243: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #244: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #245: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #246: -- Constants -- --------- #247: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #248: _DP0_ :: Tag _DP0_ = 0x00 #249: _DP1_ :: Tag _DP1_ = 0x01 #250: _VAR_ :: Tag _VAR_ = 0x02 #251: _SUB_ :: Tag _SUB_ = 0x03 #252: _REF_ :: Tag _REF_ = 0x04 #253: _LET_ :: Tag _LET_ = 0x05 #254: _APP_ :: Tag _APP_ = 0x06 #255: _ANN_ :: Tag _ANN_ = 0x07 #256: _MAT_ :: Tag _MAT_ = 0x08 #257: _OPX_ :: Tag _OPX_ = 0x09 #258: _OPY_ :: Tag _OPY_ = 0x0A #259: _ERA_ :: Tag _ERA_ = 0x0B #260: _LAM_ :: Tag _LAM_ = 0x0C #261: _SUP_ :: Tag _SUP_ = 0x0D #262: _TYP_ :: Tag _TYP_ = 0x0E #263: _CTR_ :: Tag _CTR_ = 0x0F #264: _W32_ :: Tag _W32_ = 0x10 #265: _CHR_ :: Tag _CHR_ = 0x11 #266: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #267: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #268: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #269: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #270: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #271: //./Type.hs// #272: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #273: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #274: typedef _Atomic(Term) ATerm; #275: // Runtime Types // ------------- #276: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #277: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #278: // Constants // --------- #279: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #280: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #281: #define SUP_F 0xFFE #define DUP_F 0xFFF #282: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #283: #define VOID 0x00000000000000 #284: // Heap // ---- #285: Loc get_len() { return *HVM.size; } #286: u64 get_itr() { return *HVM.itrs; } #287: void set_len(Loc value) { *HVM.size = value; } #288: void set_itr(Loc value) { *HVM.itrs = value; } #289: // Terms // ------ #290: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #291: Tag term_tag(Term x) { return x & 0x7F; } #292: Tag term_bit(Term x) { return (x >> 7) & 1; } #293: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #294: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #295: Term term_set_bit(Term term) { return term | (1ULL << 7); } #296: // u12v2 // ----- #297: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #298: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #299: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #300: // Atomics // ------- #301: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #302: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #303: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #304: Term take(Loc loc) { return swap(loc, VOID); } #305: // Allocation // ---------- #306: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #307: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #308: // Stringification // --------------- #309: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #310: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #311: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #312: // Evaluation // ---------- #313: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #314: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #315: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #316: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #317: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #318: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #319: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #320: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #321: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #322: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #323: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #324: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #325: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #327: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #328: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #329: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #330: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #331: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #332: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #333: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #334: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #335: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #336: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #337: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #338: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #339: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #340: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #341: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #342: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #343: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #344: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #345: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #346: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #347: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #348: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #349: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #350: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #351: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #352: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #353: // Primitives // ---------- #354: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #355: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #356: // Runtime Memory // -------------- #357: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #358: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #359: State* hvm_get_state() { return &HVM; } #360: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #361: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #362: -- //./Type.hs// -- //./Inject.hs// #363: module HVML.Extract where #364: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #365: import Debug.Trace #366: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #367: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #368: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #369: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #370: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #371: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #372: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #373: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #374: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #375: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #376: -- Lifting Dups -- ------------ #377: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #378: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #379: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #380: module HVML.Equal where #381: import Control.Monad (liftM2) import HVML.Type import HVML.Show #382: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #383: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #384: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #385: -- //./Type.hs// #386: module HVML.Inject where #387: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #388: type InjectM a = StateT InjectState HVM a #389: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #390: emptyState :: InjectState emptyState = InjectState Map.empty [] #391: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #392: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #393: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #394: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #395: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #396: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #397: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #398: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #399: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #400: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #401: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #402: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #403: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #404: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #405: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #406: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: -- FIXME: when SUP labels have large vals, this takes a lot of time. #3: module HVML.Collapse where #4: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #5: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #6: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #7: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #8: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #9: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #10: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #11: instance Applicative Collapse where pure = CVal (<*>) = ap #12: instance Monad Collapse where return = pure (>>=) = bind #13: -- Dup Collapser -- ------------- #14: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #15: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #16: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #17: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #18: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #19: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #20: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #21: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #22: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #23: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #25: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #26: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #27: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #28: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #29: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #31: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #32: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #33: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #34: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #35: -- Sup Collapser -- ------------- #36: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #37: -- Tree Collapser -- -------------- #38: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #39: -- Priority Queue -- -------------- #40: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #41: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #42: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #43: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #44: -- Flattener -- --------- #45: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #46: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #47: flatten :: Collapse a -> [a] flatten = flattenDFS #48: -- Flat Collapser -- -------------- #49: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #50: -- //./Type.hs// #51: module HVML.Show where #52: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #53: -- Core Stringification -- -------------------- #54: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #55: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #56: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #57: -- Runtime Stringification -- ----------------------- #58: tagToString :: Tag -> String tagToString t = show (tagT t) #59: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #60: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #61: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #62: -- Pretty Printers -- --------------- #63: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core -- pretty core = prettyStr core #64: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #65: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #66: -- Dumping -- ------- #67: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #68: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #69: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #70: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #71: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #72: -- //./Type.hs// #73: module HVML.Parse where #74: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #75: -- Core Parsers -- ------------ #76: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #77: type ParserM = Parsec String ParserState #78: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #79: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #80: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #81: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #82: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #83: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #84: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #85: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #86: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #87: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #88: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #89: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #90: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #91: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #92: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #93: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #94: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #95: -- Helper Parsers -- -------------- #96: consume :: String -> ParserM String consume str = spaces >> string str #97: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #98: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #99: -- Adjusting -- --------- #100: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #101: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #102: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #103: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #104: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #105: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #106: -- Errors -- ------ #107: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #108: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #109: -- //./Type.hs// -- //./Inject.hs// -- //./Extract.hs// #110: module HVML.Reduce where #111: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #112: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #113: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _DUP_F_ -> reduceRefAt_DupF book host loc ari x | x == _SUP_F_ -> reduceRefAt_SupF book host loc ari x | x == _LOG_F_ -> reduceRefAt_LogF book host loc ari x | x == _FRESH_F_ -> reduceRefAt_FreshF book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_DupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_DupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> do core <- doExtractCoreAt (\ x -> got) book (loc + 0) putStrLn $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab putStrLn $ coreToString (doLiftDups core) exitFailure #115: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_SupF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_SupF book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #116: -- Primitive: Logger `@LOG(msg)` -- Will extract the term and log it. -- Returns 0. reduceRefAt_LogF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_LogF book host loc ari = do incItr when (ari /= 1) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@LOG'." exitFailure msg <- doExtractCoreAt (const got) book (loc + 0) putStrLn $ coreToString (doLiftDups msg) let ret = termNew _W32_ 0 0 set host ret return ret #117: -- Primitive: Fresh `@FRESH` -- Returns a fresh dup label. reduceRefAt_FreshF :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_FreshF book host loc ari = do incItr when (ari /= 0) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@Fresh'." exitFailure num <- fresh let ret = termNew _W32_ 0 num set host ret return ret #118: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #119: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #120: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #121: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #122: -- //./Type.hs// -- //./Inject.hs// #123: module HVML.Compile where #124: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type hiding (fresh) import qualified Data.Map.Strict as MS #125: import Debug.Trace #126: -- Compilation -- ----------- #127: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #128: type Compile = State CompileState #129: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #130: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #131: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #132: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #133: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #134: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #135: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #136: -- Full Compiler -- ------------- #137: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #138: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #139: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #140: -- Fast Compiler -- ------------- #141: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #142: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #143: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #144: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #145: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #146: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #147: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #148: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #149: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #150: -- Type.hs: -- //./Type.hs// #151: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #152: module Main where #153: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #154: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #155: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #156: -- Main -- ---- #157: data RunMode = Normalize | Collapse | Search deriving Eq #158: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #159: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #160: -- CLI Commands -- ------------ #161: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #162: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #163: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #164: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #165: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #166: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #167: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #168: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #169: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #170: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #171: -- Prints total time end <- getCPUTime #172: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #173: -- Finalize hvmFree return $ Right () #174: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #175: module HVML.Type where #176: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #177: -- Core Types -- ---------- #178: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #179: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #180: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #181: type Func = ([String], Core) #182: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #183: -- Runtime Types -- ------------- #184: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #185: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #186: type HVM = IO #187: type ReduceAt = Book -> Loc -> HVM Term #188: -- C Functions -- ----------- #189: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #190: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #191: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #192: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #193: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #194: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #195: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #196: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #197: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #198: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #200: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #201: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #202: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #203: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #204: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #205: foreign import ccall unsafe "Runtime.c fresh" fresh :: IO Word64 #206: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #244: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #245: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #246: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #247: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #248: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #249: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #250: -- Constants -- --------- #251: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #252: _DP0_ :: Tag _DP0_ = 0x00 #253: _DP1_ :: Tag _DP1_ = 0x01 #254: _VAR_ :: Tag _VAR_ = 0x02 #255: _SUB_ :: Tag _SUB_ = 0x03 #256: _REF_ :: Tag _REF_ = 0x04 #257: _LET_ :: Tag _LET_ = 0x05 #258: _APP_ :: Tag _APP_ = 0x06 #259: _ANN_ :: Tag _ANN_ = 0x07 #260: _MAT_ :: Tag _MAT_ = 0x08 #261: _OPX_ :: Tag _OPX_ = 0x09 #262: _OPY_ :: Tag _OPY_ = 0x0A #263: _ERA_ :: Tag _ERA_ = 0x0B #264: _LAM_ :: Tag _LAM_ = 0x0C #265: _SUP_ :: Tag _SUP_ = 0x0D #266: _TYP_ :: Tag _TYP_ = 0x0E #267: _CTR_ :: Tag _CTR_ = 0x0F #268: _W32_ :: Tag _W32_ = 0x10 #269: _CHR_ :: Tag _CHR_ = 0x11 #270: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #271: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #272: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #273: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #274: _LOG_F_ :: Lab _LOG_F_ = 0xFFD #275: _FRESH_F_ :: Lab _FRESH_F_ = 0xFFC #276: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) , ("LOG", _LOG_F_) , ("FRESH", _FRESH_F_) ] ./Runtime.c #277: //./Type.hs// #278: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #279: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #280: typedef _Atomic(Term) ATerm; #281: // Runtime Types // ------------- #282: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count u64* frsh; // fresh dup label count Term (*book[4096])(Term); // functions } State; #283: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .frsh = NULL, .book = {NULL} }; #284: // Constants // --------- #285: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #286: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #287: #define DUP_F 0xFFF #define SUP_F 0xFFE #define LOG_F 0xFFD #define FRESH_F 0xFFC #288: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #289: #define VOID 0x00000000000000 #290: // Heap // ---- #291: Loc get_len() { return *HVM.size; } #292: u64 get_itr() { return *HVM.itrs; } #293: u64 fresh() { return (*HVM.frsh)++; } #294: void set_len(Loc value) { *HVM.size = value; } #295: void set_itr(Loc value) { *HVM.itrs = value; } #296: // Terms // ------ #297: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #298: Tag term_tag(Term x) { return x & 0x7F; } #299: Tag term_bit(Term x) { return (x >> 7) & 1; } #300: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #301: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #302: Term term_set_bit(Term term) { return term | (1ULL << 7); } #303: // u12v2 // ----- #304: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #305: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #306: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #307: // Atomics // ------- #308: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #309: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #310: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #311: Term take(Loc loc) { return swap(loc, VOID); } #312: // Allocation // ---------- #313: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #314: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #315: // Stringification // --------------- #316: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #317: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #318: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #319: // Evaluation // ---------- #320: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #321: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #322: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #323: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #324: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #325: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #326: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #327: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #328: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #329: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #330: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #331: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #332: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #333: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #334: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #335: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #336: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #337: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #338: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #339: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #340: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #341: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #342: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #343: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #344: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #345: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #346: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #347: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #348: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #349: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #350: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #351: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #352: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #353: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #354: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #355: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #356: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #357: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #358: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #359: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #360: // Primitives // ---------- #361: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #362: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); if (term_tag(lab) != W32) { printf("ERROR\n"); } Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #363: Term LOG_f(Term ref) { printf("TODO: LOG_f"); exit(0); } #364: Term FRESH_f(Term ref) { printf("TODO: FRESH_f"); exit(0); } #365: // Runtime Memory // -------------- #366: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.frsh = malloc(sizeof(u64)); *HVM.frsh = 0x20; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; HVM.book[LOG_F] = LOG_f; HVM.book[FRESH_F] = FRESH_f; } #367: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); free(HVM.frsh); } #368: State* hvm_get_state() { return &HVM; } #369: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; HVM.frsh = hvm->frsh; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #370: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #371: -- //./Type.hs// -- //./Inject.hs// #372: module HVML.Extract where #373: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #374: import Debug.Trace #375: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #376: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #377: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #378: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #379: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #380: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #381: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term sub <- got (loc + 0) if termTag sub == _SUB_ then do name <- genName state loc return $ Var name else do extractCoreAt state reduceAt book (loc + 0) #382: DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #383: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #384: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #385: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #386: -- Lifting Dups -- ------------ #387: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #388: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #389: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #390: module HVML.Equal where #391: import Control.Monad (liftM2) import HVML.Type import HVML.Show #392: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #393: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #394: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #395: -- //./Type.hs// #396: module HVML.Inject where #397: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #398: type InjectM a = StateT InjectState HVM a #399: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #400: emptyState :: InjectState emptyState = InjectState Map.empty [] #401: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #402: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #403: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #404: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #405: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #406: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #407: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #408: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #409: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #410: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #411: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #412: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #413: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #414: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #415: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #416: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

d11a471b8d7f9f6c7ade6355af8d1883810bef43

lift dups on debug mode

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// -- //./Inject.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #113: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> error $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab #115: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #116: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #117: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #118: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #119: -- //./Type.hs// -- //./Inject.hs// #120: module HVML.Compile where #121: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #122: import Debug.Trace #123: -- Compilation -- ----------- #124: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #125: type Compile = State CompileState #126: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #127: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #128: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #129: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #130: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #131: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #132: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #133: -- Full Compiler -- ------------- #134: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #135: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #136: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #137: -- Fast Compiler -- ------------- #138: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #139: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #140: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #141: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #142: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #143: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #144: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #146: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #147: -- Type.hs: -- //./Type.hs// #148: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #149: module Main where #150: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #151: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #152: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #153: -- Main -- ---- #154: data RunMode = Normalize | Collapse | Search deriving Eq #155: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #156: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #157: -- CLI Commands -- ------------ #158: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #159: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #160: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #161: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #162: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #163: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #164: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #165: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #166: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #167: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #168: -- Prints total time end <- getCPUTime #169: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #170: -- Finalize hvmFree return $ Right () #171: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #172: module HVML.Type where #173: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #174: -- Core Types -- ---------- #175: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #176: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #177: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #178: type Func = ([String], Core) #179: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #180: -- Runtime Types -- ------------- #181: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #182: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #183: type HVM = IO #184: type ReduceAt = Book -> Loc -> HVM Term #185: -- C Functions -- ----------- #186: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #187: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #188: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #189: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #190: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #191: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #192: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #193: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #194: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #195: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #196: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #197: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #198: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #200: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #201: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #202: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #241: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #242: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #243: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #244: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #245: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #246: -- Constants -- --------- #247: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #248: _DP0_ :: Tag _DP0_ = 0x00 #249: _DP1_ :: Tag _DP1_ = 0x01 #250: _VAR_ :: Tag _VAR_ = 0x02 #251: _SUB_ :: Tag _SUB_ = 0x03 #252: _REF_ :: Tag _REF_ = 0x04 #253: _LET_ :: Tag _LET_ = 0x05 #254: _APP_ :: Tag _APP_ = 0x06 #255: _ANN_ :: Tag _ANN_ = 0x07 #256: _MAT_ :: Tag _MAT_ = 0x08 #257: _OPX_ :: Tag _OPX_ = 0x09 #258: _OPY_ :: Tag _OPY_ = 0x0A #259: _ERA_ :: Tag _ERA_ = 0x0B #260: _LAM_ :: Tag _LAM_ = 0x0C #261: _SUP_ :: Tag _SUP_ = 0x0D #262: _TYP_ :: Tag _TYP_ = 0x0E #263: _CTR_ :: Tag _CTR_ = 0x0F #264: _W32_ :: Tag _W32_ = 0x10 #265: _CHR_ :: Tag _CHR_ = 0x11 #266: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #267: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #268: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #269: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #270: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #271: //./Type.hs// #272: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #273: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #274: typedef _Atomic(Term) ATerm; #275: // Runtime Types // ------------- #276: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #277: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #278: // Constants // --------- #279: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #280: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #281: #define SUP_F 0xFFE #define DUP_F 0xFFF #282: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #283: #define VOID 0x00000000000000 #284: // Heap // ---- #285: Loc get_len() { return *HVM.size; } #286: u64 get_itr() { return *HVM.itrs; } #287: void set_len(Loc value) { *HVM.size = value; } #288: void set_itr(Loc value) { *HVM.itrs = value; } #289: // Terms // ------ #290: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #291: Tag term_tag(Term x) { return x & 0x7F; } #292: Tag term_bit(Term x) { return (x >> 7) & 1; } #293: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #294: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #295: Term term_set_bit(Term term) { return term | (1ULL << 7); } #296: // u12v2 // ----- #297: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #298: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #299: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #300: // Atomics // ------- #301: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #302: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #303: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #304: Term take(Loc loc) { return swap(loc, VOID); } #305: // Allocation // ---------- #306: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #307: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #308: // Stringification // --------------- #309: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #310: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #311: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #312: // Evaluation // ---------- #313: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #314: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #315: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #316: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #317: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #318: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #319: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #320: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #321: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #322: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #323: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #324: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #325: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #327: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #328: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #329: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #330: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #331: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #332: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #333: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #334: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #335: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #336: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #337: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #338: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #339: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #340: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #341: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #342: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #343: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #344: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #345: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #346: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #347: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #348: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #349: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #350: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #351: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #352: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #353: // Primitives // ---------- #354: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #355: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #356: // Runtime Memory // -------------- #357: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #358: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #359: State* hvm_get_state() { return &HVM; } #360: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #361: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #362: -- //./Type.hs// -- //./Inject.hs// #363: module HVML.Extract where #364: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #365: import Debug.Trace #366: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #367: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #368: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #369: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #370: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #371: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #372: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #373: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #374: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #375: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #376: -- Lifting Dups -- ------------ #377: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #378: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #379: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #380: module HVML.Equal where #381: import Control.Monad (liftM2) import HVML.Type import HVML.Show #382: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #383: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #384: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #385: -- //./Type.hs// #386: module HVML.Inject where #387: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #388: type InjectM a = StateT InjectState HVM a #389: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #390: emptyState :: InjectState emptyState = InjectState Map.empty [] #391: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #392: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #393: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #394: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #395: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #396: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #397: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #398: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #399: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #400: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #401: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #402: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #403: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #404: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #405: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #406: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// -- //./Inject.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString (doLiftDups root) case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #113: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> error $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab #115: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #116: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #117: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #118: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #119: -- //./Type.hs// -- //./Inject.hs// #120: module HVML.Compile where #121: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #122: import Debug.Trace #123: -- Compilation -- ----------- #124: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #125: type Compile = State CompileState #126: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #127: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #128: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #129: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #130: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #131: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #132: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #133: -- Full Compiler -- ------------- #134: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #135: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #136: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #137: -- Fast Compiler -- ------------- #138: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #139: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #140: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #141: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #142: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #143: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #144: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #146: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #147: -- Type.hs: -- //./Type.hs// #148: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #149: module Main where #150: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #151: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #152: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #153: -- Main -- ---- #154: data RunMode = Normalize | Collapse | Search deriving Eq #155: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #156: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #157: -- CLI Commands -- ------------ #158: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #159: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #160: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #161: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #162: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #163: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #164: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #165: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #166: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #167: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #168: -- Prints total time end <- getCPUTime #169: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #170: -- Finalize hvmFree return $ Right () #171: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #172: module HVML.Type where #173: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #174: -- Core Types -- ---------- #175: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #176: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #177: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #178: type Func = ([String], Core) #179: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #180: -- Runtime Types -- ------------- #181: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #182: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #183: type HVM = IO #184: type ReduceAt = Book -> Loc -> HVM Term #185: -- C Functions -- ----------- #186: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #187: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #188: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #189: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #190: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #191: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #192: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #193: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #194: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #195: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #196: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #197: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #198: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #200: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #201: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #202: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #241: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #242: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #243: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #244: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #245: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #246: -- Constants -- --------- #247: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #248: _DP0_ :: Tag _DP0_ = 0x00 #249: _DP1_ :: Tag _DP1_ = 0x01 #250: _VAR_ :: Tag _VAR_ = 0x02 #251: _SUB_ :: Tag _SUB_ = 0x03 #252: _REF_ :: Tag _REF_ = 0x04 #253: _LET_ :: Tag _LET_ = 0x05 #254: _APP_ :: Tag _APP_ = 0x06 #255: _ANN_ :: Tag _ANN_ = 0x07 #256: _MAT_ :: Tag _MAT_ = 0x08 #257: _OPX_ :: Tag _OPX_ = 0x09 #258: _OPY_ :: Tag _OPY_ = 0x0A #259: _ERA_ :: Tag _ERA_ = 0x0B #260: _LAM_ :: Tag _LAM_ = 0x0C #261: _SUP_ :: Tag _SUP_ = 0x0D #262: _TYP_ :: Tag _TYP_ = 0x0E #263: _CTR_ :: Tag _CTR_ = 0x0F #264: _W32_ :: Tag _W32_ = 0x10 #265: _CHR_ :: Tag _CHR_ = 0x11 #266: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #267: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #268: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #269: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #270: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #271: //./Type.hs// #272: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #273: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #274: typedef _Atomic(Term) ATerm; #275: // Runtime Types // ------------- #276: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #277: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #278: // Constants // --------- #279: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #280: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #281: #define SUP_F 0xFFE #define DUP_F 0xFFF #282: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #283: #define VOID 0x00000000000000 #284: // Heap // ---- #285: Loc get_len() { return *HVM.size; } #286: u64 get_itr() { return *HVM.itrs; } #287: void set_len(Loc value) { *HVM.size = value; } #288: void set_itr(Loc value) { *HVM.itrs = value; } #289: // Terms // ------ #290: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #291: Tag term_tag(Term x) { return x & 0x7F; } #292: Tag term_bit(Term x) { return (x >> 7) & 1; } #293: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #294: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #295: Term term_set_bit(Term term) { return term | (1ULL << 7); } #296: // u12v2 // ----- #297: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #298: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #299: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #300: // Atomics // ------- #301: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #302: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #303: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #304: Term take(Loc loc) { return swap(loc, VOID); } #305: // Allocation // ---------- #306: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #307: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #308: // Stringification // --------------- #309: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #310: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #311: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #312: // Evaluation // ---------- #313: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #314: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #315: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #316: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #317: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #318: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #319: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #320: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #321: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #322: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #323: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #324: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #325: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #327: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #328: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #329: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #330: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #331: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #332: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #333: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #334: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #335: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #336: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #337: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #338: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #339: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #340: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #341: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #342: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #343: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #344: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #345: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #346: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #347: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #348: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #349: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #350: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #351: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #352: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #353: // Primitives // ---------- #354: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #355: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #356: // Runtime Memory // -------------- #357: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #358: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #359: State* hvm_get_state() { return &HVM; } #360: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #361: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #362: -- //./Type.hs// -- //./Inject.hs// #363: module HVML.Extract where #364: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #365: import Debug.Trace #366: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #367: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #368: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #369: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #370: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #371: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #372: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #373: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #374: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #375: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #376: -- Lifting Dups -- ------------ #377: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #378: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #379: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #380: module HVML.Equal where #381: import Control.Monad (liftM2) import HVML.Type import HVML.Show #382: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #383: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #384: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #385: -- //./Type.hs// #386: module HVML.Inject where #387: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #388: type InjectM a = StateT InjectState HVM a #389: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #390: emptyState :: InjectState emptyState = InjectState Map.empty [] #391: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #392: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #393: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #394: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #395: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #396: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #397: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #398: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #399: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #400: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #401: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #402: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #403: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #404: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #405: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #406: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

1f1537d2dd7ab7212006af70db59110041de8184

minor optimizations and fixes

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// -- //./Inject.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #113: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic DUP without numeric label." #115: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #116: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #117: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #118: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #119: -- //./Type.hs// -- //./Inject.hs// #120: module HVML.Compile where #121: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #122: import Debug.Trace #123: -- Compilation -- ----------- #124: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #125: type Compile = State CompileState #126: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #127: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #128: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #129: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #130: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #131: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #132: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #133: -- Full Compiler -- ------------- #134: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #135: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #136: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #137: -- Fast Compiler -- ------------- #138: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #139: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #140: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #141: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #142: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #143: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #144: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #146: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #147: -- Type.hs: -- //./Type.hs// #148: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #149: module Main where #150: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #151: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #152: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #153: -- Main -- ---- #154: data RunMode = Normalize | Collapse | Search deriving Eq #155: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #156: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #157: -- CLI Commands -- ------------ #158: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #159: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #160: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #161: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #162: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #163: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #164: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #165: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #166: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #167: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #168: -- Prints total time end <- getCPUTime #169: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #170: -- Finalize hvmFree return $ Right () #171: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #172: module HVML.Type where #173: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #174: -- Core Types -- ---------- #175: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #176: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #177: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #178: type Func = ([String], Core) #179: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #180: -- Runtime Types -- ------------- #181: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #182: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #183: type HVM = IO #184: type ReduceAt = Book -> Loc -> HVM Term #185: -- C Functions -- ----------- #186: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #187: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #188: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #189: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #190: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #191: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #192: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #193: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #194: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #195: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #196: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #197: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #198: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #200: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #201: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #202: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #241: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #242: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #243: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #244: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #245: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #246: -- Constants -- --------- #247: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #248: _DP0_ :: Tag _DP0_ = 0x00 #249: _DP1_ :: Tag _DP1_ = 0x01 #250: _VAR_ :: Tag _VAR_ = 0x02 #251: _SUB_ :: Tag _SUB_ = 0x03 #252: _REF_ :: Tag _REF_ = 0x04 #253: _LET_ :: Tag _LET_ = 0x05 #254: _APP_ :: Tag _APP_ = 0x06 #255: _ANN_ :: Tag _ANN_ = 0x07 #256: _MAT_ :: Tag _MAT_ = 0x08 #257: _OPX_ :: Tag _OPX_ = 0x09 #258: _OPY_ :: Tag _OPY_ = 0x0A #259: _ERA_ :: Tag _ERA_ = 0x0B #260: _LAM_ :: Tag _LAM_ = 0x0C #261: _SUP_ :: Tag _SUP_ = 0x0D #262: _TYP_ :: Tag _TYP_ = 0x0E #263: _CTR_ :: Tag _CTR_ = 0x0F #264: _W32_ :: Tag _W32_ = 0x10 #265: _CHR_ :: Tag _CHR_ = 0x11 #266: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #267: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #268: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #269: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #270: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #271: //./Type.hs// //./Reduce.hs// #272: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #273: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #274: typedef _Atomic(Term) ATerm; #275: // Runtime Types // ------------- #276: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #277: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #278: // Constants // --------- #279: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #280: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #281: #define SUP_F 0xFFE #define DUP_F 0xFFF #282: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #283: #define VOID 0x00000000000000 #284: // Heap // ---- #285: Loc get_len() { return *HVM.size; } #286: u64 get_itr() { return *HVM.itrs; } #287: void set_len(Loc value) { *HVM.size = value; } #288: void set_itr(Loc value) { *HVM.itrs = value; } #289: // Terms // ------ #290: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #291: Tag term_tag(Term x) { return x & 0x7F; } #292: Tag term_bit(Term x) { return (x >> 7) & 1; } #293: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #294: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #295: Term term_set_bit(Term term) { return term | (1ULL << 7); } #296: // u12v2 // ----- #297: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #298: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #299: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #300: // Atomics // ------- #301: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #302: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #303: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #304: Term take(Loc loc) { return swap(loc, VOID); } #305: // Allocation // ---------- #306: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #307: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #308: // Stringification // --------------- #309: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #310: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #311: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #312: // Evaluation // ---------- #313: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #314: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #315: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #316: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #317: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #318: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #319: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #320: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #321: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #322: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #323: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #324: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #325: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #327: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #328: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #329: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #330: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #331: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #332: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #333: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #334: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #335: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #336: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #337: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #338: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #339: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #340: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #341: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #342: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #343: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #344: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #345: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #346: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #347: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #348: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #349: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #350: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #351: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #352: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #353: // Primitives // ---------- #354: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #355: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #356: // Runtime Memory // -------------- #357: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #358: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #359: State* hvm_get_state() { return &HVM; } #360: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #361: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #362: -- //./Type.hs// -- //./Inject.hs// #363: module HVML.Extract where #364: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #365: import Debug.Trace #366: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #367: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #368: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #369: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #370: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #371: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #372: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #373: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #374: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #375: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #376: -- Lifting Dups -- ------------ #377: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #378: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #379: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #380: module HVML.Equal where #381: import Control.Monad (liftM2) import HVML.Type import HVML.Show #382: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #383: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #384: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #385: -- //./Type.hs// #386: module HVML.Inject where #387: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #388: type InjectM a = StateT InjectState HVM a #389: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #390: emptyState :: InjectState emptyState = InjectState Map.empty [] #391: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #392: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #393: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #394: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #395: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #396: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #397: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #398: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #399: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #400: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #401: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #402: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #403: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #404: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #405: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #406: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- optionMaybe $ try $ do nam <- parseName consume "=" return nam val <- parseCore bod <- parseCore case nam of Just nam -> return $ Let STRI nam val bod Nothing -> return $ Let STRI "_" val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// -- //./Inject.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari otherwise -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #113: -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic SUP label too large" let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #114: -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@DUP'." exitFailure lab <- reduceAt False book (loc + 0) val <- got (loc + 1) bod <- got (loc + 2) dup <- allocNode 2 case tagT (termTag lab) of W32 -> do when (termLoc lab >= 0x1000000) $ do error "RUNTIME_ERROR: dynamic DUP label too large" -- Create the DUP node with value and SUB set (dup + 0) val set (dup + 1) (termNew _SUB_ 0 0) -- Create first APP node for (APP bod DP0) app1 <- allocNode 2 set (app1 + 0) bod set (app1 + 1) (termNew _DP0_ (termLoc lab) dup) -- Create second APP node for (APP (APP bod DP0) DP1) app2 <- allocNode 2 set (app2 + 0) (termNew _APP_ 0 app1) set (app2 + 1) (termNew _DP1_ (termLoc lab) dup) let ret = termNew _APP_ 0 app2 set host ret return ret _ -> error $ "RUNTIME_ERROR: dynamic DUP without numeric label: " ++ termToString lab #115: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #116: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #117: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #118: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #119: -- //./Type.hs// -- //./Inject.hs// #120: module HVML.Compile where #121: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #122: import Debug.Trace #123: -- Compilation -- ----------- #124: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #125: type Compile = State CompileState #126: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #127: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #128: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #129: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #130: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #131: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #132: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #133: -- Full Compiler -- ------------- #134: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #135: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #136: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #137: -- Fast Compiler -- ------------- #138: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #139: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #140: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #141: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #142: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #143: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #144: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #145: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #146: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #147: -- Type.hs: -- //./Type.hs// #148: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #149: module Main where #150: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #151: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #152: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #153: -- Main -- ---- #154: data RunMode = Normalize | Collapse | Search deriving Eq #155: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #156: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #157: -- CLI Commands -- ------------ #158: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #159: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #160: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #161: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #162: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #163: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #164: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #165: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #166: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #167: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #168: -- Prints total time end <- getCPUTime #169: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #170: -- Finalize hvmFree return $ Right () #171: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #172: module HVML.Type where #173: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #174: -- Core Types -- ---------- #175: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #176: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #177: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #178: type Func = ([String], Core) #179: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #180: -- Runtime Types -- ------------- #181: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #182: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #183: type HVM = IO #184: type ReduceAt = Book -> Loc -> HVM Term #185: -- C Functions -- ----------- #186: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #187: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #188: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #189: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #190: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #191: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #192: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #193: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #194: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #195: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #196: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #197: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #198: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #200: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #201: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #202: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #241: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #242: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #243: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #244: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #245: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #246: -- Constants -- --------- #247: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #248: _DP0_ :: Tag _DP0_ = 0x00 #249: _DP1_ :: Tag _DP1_ = 0x01 #250: _VAR_ :: Tag _VAR_ = 0x02 #251: _SUB_ :: Tag _SUB_ = 0x03 #252: _REF_ :: Tag _REF_ = 0x04 #253: _LET_ :: Tag _LET_ = 0x05 #254: _APP_ :: Tag _APP_ = 0x06 #255: _ANN_ :: Tag _ANN_ = 0x07 #256: _MAT_ :: Tag _MAT_ = 0x08 #257: _OPX_ :: Tag _OPX_ = 0x09 #258: _OPY_ :: Tag _OPY_ = 0x0A #259: _ERA_ :: Tag _ERA_ = 0x0B #260: _LAM_ :: Tag _LAM_ = 0x0C #261: _SUP_ :: Tag _SUP_ = 0x0D #262: _TYP_ :: Tag _TYP_ = 0x0E #263: _CTR_ :: Tag _CTR_ = 0x0F #264: _W32_ :: Tag _W32_ = 0x10 #265: _CHR_ :: Tag _CHR_ = 0x11 #266: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #267: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #268: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #269: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #270: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #271: //./Type.hs// #272: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #273: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #274: typedef _Atomic(Term) ATerm; #275: // Runtime Types // ------------- #276: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #277: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #278: // Constants // --------- #279: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #280: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #281: #define SUP_F 0xFFE #define DUP_F 0xFFF #282: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #283: #define VOID 0x00000000000000 #284: // Heap // ---- #285: Loc get_len() { return *HVM.size; } #286: u64 get_itr() { return *HVM.itrs; } #287: void set_len(Loc value) { *HVM.size = value; } #288: void set_itr(Loc value) { *HVM.itrs = value; } #289: // Terms // ------ #290: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #291: Tag term_tag(Term x) { return x & 0x7F; } #292: Tag term_bit(Term x) { return (x >> 7) & 1; } #293: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #294: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #295: Term term_set_bit(Term term) { return term | (1ULL << 7); } #296: // u12v2 // ----- #297: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #298: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #299: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #300: // Atomics // ------- #301: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #302: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #303: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #304: Term take(Loc loc) { return swap(loc, VOID); } #305: // Allocation // ---------- #306: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #307: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #308: // Stringification // --------------- #309: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #310: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #311: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #312: // Evaluation // ---------- #313: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #314: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #315: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #316: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #317: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #318: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #319: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #320: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #321: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #322: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #323: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #324: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #325: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // x <- #{a0 b0 c0 ...} // y <- #{a1 b1 c1 ...} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #327: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #328: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #329: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #330: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #331: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #332: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #333: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #334: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #335: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #336: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #337: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #338: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #339: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #340: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #341: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #342: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #343: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #344: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #345: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #346: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #347: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #348: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #349: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #350: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #351: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #352: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #353: // Primitives // ---------- #354: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(lab), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #355: // Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` // Creates a DUP node with given label. Term DUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = reduce(got(ref_loc + 0)); Term val = got(ref_loc + 1); Term bod = got(ref_loc + 2); Loc dup = alloc_node(2); set(dup + 0, val); set(dup + 1, term_new(SUB, 0, 0)); Loc app1 = alloc_node(2); set(app1 + 0, bod); set(app1 + 1, term_new(DP0, term_loc(lab), dup)); Loc app2 = alloc_node(2); set(app2 + 0, term_new(APP, 0, app1)); set(app2 + 1, term_new(DP1, term_loc(lab), dup)); return term_new(APP, 0, app2); } #356: // Runtime Memory // -------------- #357: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #358: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #359: State* hvm_get_state() { return &HVM; } #360: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #361: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #362: -- //./Type.hs// -- //./Inject.hs// #363: module HVML.Extract where #364: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #365: import Debug.Trace #366: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #367: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #368: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #369: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #370: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #371: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #372: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #373: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #374: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #375: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #376: -- Lifting Dups -- ------------ #377: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #378: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #379: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #380: module HVML.Equal where #381: import Control.Monad (liftM2) import HVML.Type import HVML.Show #382: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #383: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #384: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #385: -- //./Type.hs// #386: module HVML.Inject where #387: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #388: type InjectM a = StateT InjectState HVM a #389: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #390: emptyState :: InjectState emptyState = InjectState Map.empty [] #391: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #392: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #393: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #394: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #395: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #396: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #397: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #398: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #399: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #400: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #401: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #402: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #403: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #404: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #405: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #406: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

429d78bd728f8935e480187df67fa2a725ef346c

dynamic sup/dup primitives; inc book size to 4096

./Collapse.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Flattener -- --------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #44: -- Flat Collapser -- -------------- #45: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #46: -- //./Type.hs// #47: module HVML.Show where #48: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #49: -- Core Stringification -- -------------------- #50: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #51: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #52: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #53: -- Runtime Stringification -- ----------------------- #54: tagToString :: Tag -> String tagToString t = show (tagT t) #55: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #56: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #57: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #58: -- Pretty Printers -- --------------- #59: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core #60: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #61: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #62: -- Dumping -- ------- #63: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #64: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #65: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #66: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #67: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #68: -- //./Type.hs// #69: module HVML.Parse where #70: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #71: -- Core Parsers -- ------------ #72: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #73: type ParserM = Parsec String ParserState #74: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #75: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #76: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #77: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #78: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #79: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #80: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #81: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #82: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #83: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #84: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #85: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #86: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #87: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #88: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #89: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #90: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #91: -- Helper Parsers -- -------------- #92: consume :: String -> ParserM String consume str = spaces >> string str #93: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #94: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #95: -- Adjusting -- --------- #96: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #97: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #98: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #99: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #100: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #101: -- Errors -- ------ #102: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #103: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #104: -- //./Type.hs// #105: module HVML.Reduce where #106: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #107: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #108: -- TODO: move REf logic to this fn reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> do error $ "unbound-function-id:" ++ show fid #109: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #110: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #111: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #112: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #113: -- //./Type.hs// -- //./Inject.hs// #114: module HVML.Compile where #115: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #116: import Debug.Trace #117: -- Compilation -- ----------- #118: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #119: type Compile = State CompileState #120: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #121: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #122: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #123: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #124: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #125: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #126: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #127: -- Full Compiler -- ------------- #128: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #129: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #130: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #131: -- Fast Compiler -- ------------- #132: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #133: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #134: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #135: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #136: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #137: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #138: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #139: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #140: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #141: -- Type.hs: -- //./Type.hs// #142: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #143: module Main where #144: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #145: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #146: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #147: -- Main -- ---- #148: data RunMode = Normalize | Collapse | Search deriving Eq #149: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #150: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #151: -- CLI Commands -- ------------ #152: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #153: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #154: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #155: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #156: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #157: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #158: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #159: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #160: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #161: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #162: -- Prints total time end <- getCPUTime #163: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #164: -- Finalize hvmFree return $ Right () #165: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #166: module HVML.Type where #167: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #168: -- Core Types -- ---------- #169: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #170: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #171: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #172: type Func = ([String], Core) #173: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #174: -- Runtime Types -- ------------- #175: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #176: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #177: type HVM = IO #178: type ReduceAt = Book -> Loc -> HVM Term #179: -- C Functions -- ----------- #180: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #181: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #182: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #183: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #184: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #185: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #186: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #187: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #188: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #189: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #190: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #191: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #192: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #193: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #194: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #195: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #196: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #235: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #236: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #237: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #238: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #239: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #240: -- Constants -- --------- #241: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #242: _DP0_ :: Tag _DP0_ = 0x00 #243: _DP1_ :: Tag _DP1_ = 0x01 #244: _VAR_ :: Tag _VAR_ = 0x02 #245: _SUB_ :: Tag _SUB_ = 0x03 #246: _REF_ :: Tag _REF_ = 0x04 #247: _LET_ :: Tag _LET_ = 0x05 #248: _APP_ :: Tag _APP_ = 0x06 #249: _ANN_ :: Tag _ANN_ = 0x07 #250: _MAT_ :: Tag _MAT_ = 0x08 #251: _OPX_ :: Tag _OPX_ = 0x09 #252: _OPY_ :: Tag _OPY_ = 0x0A #253: _ERA_ :: Tag _ERA_ = 0x0B #254: _LAM_ :: Tag _LAM_ = 0x0C #255: _SUP_ :: Tag _SUP_ = 0x0D #256: _TYP_ :: Tag _TYP_ = 0x0E #257: _CTR_ :: Tag _CTR_ = 0x0F #258: _W32_ :: Tag _W32_ = 0x10 #259: _CHR_ :: Tag _CHR_ = 0x11 #260: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #261: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key ./Runtime.c #262: //./Type.hs// #263: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #264: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #265: typedef _Atomic(Term) ATerm; #266: // Runtime Types // ------------- #267: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #268: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #269: // Constants // --------- #270: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #271: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #272: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #273: #define VOID 0x00000000000000 #274: // Heap // ---- #275: Loc get_len() { return *HVM.size; } #276: u64 get_itr() { return *HVM.itrs; } #277: void set_len(Loc value) { *HVM.size = value; } #278: void set_itr(Loc value) { *HVM.itrs = value; } #279: // Terms // ------ #280: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #281: Tag term_tag(Term x) { return x & 0x7F; } #282: Tag term_bit(Term x) { return (x >> 7) & 1; } #283: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #284: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #285: Term term_set_bit(Term term) { return term | (1ULL << 7); } #286: // u12v2 // ----- #287: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #288: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #289: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #290: // Atomics // ------- #291: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #292: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #293: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #294: Term take(Loc loc) { return swap(loc, VOID); } #295: // Allocation // ---------- #296: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #297: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #298: // Stringification // --------------- #299: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #300: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #301: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #302: // Evaluation // ---------- #303: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #304: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #305: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #306: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #307: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #308: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #309: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #310: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #311: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #312: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #313: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #314: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #315: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #316: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #317: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #318: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #319: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #320: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #321: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #322: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #323: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #324: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #325: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #326: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #327: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #328: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #329: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #330: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #331: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #332: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #333: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #334: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #335: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #336: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #337: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #338: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #339: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #340: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #341: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #342: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #343: // Runtime Memory // -------------- #344: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #345: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #346: State* hvm_get_state() { return &HVM; } #347: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #348: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #349: -- //./Type.hs// -- //./Inject.hs// #350: module HVML.Extract where #351: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #352: import Debug.Trace #353: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #354: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #355: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #356: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #357: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #358: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #359: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #360: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #361: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #362: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #363: -- Lifting Dups -- ------------ #364: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #365: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #366: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #367: module HVML.Equal where #368: import Control.Monad (liftM2) import HVML.Type import HVML.Show #369: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #370: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #371: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #372: -- //./Type.hs// #373: module HVML.Inject where #374: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #375: type InjectM a = StateT InjectState HVM a #376: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #377: emptyState :: InjectState emptyState = InjectState Map.empty [] #378: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #379: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #380: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #381: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #382: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #383: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #384: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #385: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #386: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #387: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #388: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #389: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #390: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #391: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #392: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #393: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Priority Queue -- -------------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: -- Flattener -- --------- #44: flattenDFS :: Collapse a -> [a] flattenDFS (CSup k a b) = flatten a ++ flatten b flattenDFS (CVal x) = [x] flattenDFS CEra = [] #45: flattenPQ :: Collapse a -> [a] flattenPQ term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #46: flatten :: Collapse a -> [a] flatten = flattenPQ #47: -- Flat Collapser -- -------------- #48: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #49: -- //./Type.hs// #50: module HVML.Show where #51: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #52: -- Core Stringification -- -------------------- #53: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #54: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #55: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #56: -- Runtime Stringification -- ----------------------- #57: tagToString :: Tag -> String tagToString t = show (tagT t) #58: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #59: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #60: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #61: -- Pretty Printers -- --------------- #62: pretty :: Core -> Maybe String -- pretty core = prettyStr core <|> prettyLst core pretty core = prettyStr core #63: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #64: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #65: -- Dumping -- ------- #66: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #67: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #68: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #69: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #70: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #71: -- //./Type.hs// #72: module HVML.Parse where #73: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #74: -- Core Parsers -- ------------ #75: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #76: type ParserM = Parsec String ParserState #77: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #78: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #79: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #80: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #81: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #82: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #83: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #84: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #85: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #86: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #87: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #88: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #89: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #90: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #91: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #92: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #93: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #94: -- Helper Parsers -- -------------- #95: consume :: String -> ParserM String consume str = spaces >> string str #96: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #97: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #98: -- Adjusting -- --------- #99: -- TODO: create a 'registerPrim' function that adds the following entries to the nameToId map: -- "SUP" -> 0xFFFFFE -- "DUP" -> 0xFFFFFF -- its type must receive/return a map #100: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let withPrims = \ n2i -> MS.union n2i $ MS.fromList primitives nameToId' = withPrims $ MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #101: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #102: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #103: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #104: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #105: -- Errors -- ------ #106: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #107: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #108: -- //./Type.hs// #109: module HVML.Reduce where #110: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #111: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #112: -- TODO: #113: -- -- TODO: move REf logic to this fn -- reduceRefAt :: Book -> Loc -> HVM Term -- reduceRefAt book host = do -- term <- got host -- let lab = termLab term -- let loc = termLoc term -- let fid = u12v2X lab -- let ari = u12v2Y lab -- putStrLn $ ">> " ++ show fid -- -- Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` -- if fid == _SUP_F_ then do -- incItr -- when (ari /= 3) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." -- exitFailure -- lab <- reduceAt False book (loc + 0) -- tm0 <- got (loc + 1) -- tm1 <- got (loc + 2) -- sup <- allocNode 2 -- case tagT (termTag lab) of -- W32 -> do -- let ret = termNew _SUP_ (termLoc lab) sup -- set (sup + 0) tm0 -- set (sup + 1) tm1 -- set host ret -- return ret -- _ -> do -- error "RUNTIME_ERROR: dynamic SUP without numeric label." -- -- Primitive: Dynamic Dup `@DUP(lab val λdp0λdp1(bod))` -- else if fid == _DUP_F_ then do -- error "TODO: dynamic dups" -- -- User Function -- else case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- Nothing -> do -- error $ "unbound-function-id:" ++ show fid #114: -- TODO: clean up the function above by moving dynamic functions (SUP_F, DUP_F) to a separate call dedicated for them. -- remember: SEPARATE these functions out of reduceRefAt. create aux fns for them -- call it: reduceRefAt_Sup / reduceRefAt_Dup -- keep the user-defined function logic inside reduceRefAt -- do not use 'if fid == ...'; use a case-of instead. #115: reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case fid of -- Dynamic Sup x | x == _SUP_F_ -> reduceRefAt_Sup book host loc ari -- Dynamic Dup x | x == _DUP_F_ -> reduceRefAt_Dup book host loc ari -- User Function _ -> case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> return term #116: reduceRefAt_Sup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Sup book host loc ari = do incItr when (ari /= 3) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@SUP'." exitFailure lab <- reduceAt False book (loc + 0) tm0 <- got (loc + 1) tm1 <- got (loc + 2) sup <- allocNode 2 case tagT (termTag lab) of W32 -> do let ret = termNew _SUP_ (termLoc lab) sup set (sup + 0) tm0 set (sup + 1) tm1 set host ret return ret _ -> error "RUNTIME_ERROR: dynamic SUP without numeric label." #117: reduceRefAt_Dup :: Book -> Loc -> Loc -> Word64 -> HVM Term reduceRefAt_Dup book host loc ari = do error "TODO: dynamic dups" #118: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #119: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #120: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #121: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #122: -- //./Type.hs// -- //./Inject.hs// #123: module HVML.Compile where #124: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #125: import Debug.Trace #126: -- Compilation -- ----------- #127: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #128: type Compile = State CompileState #129: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #130: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #131: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #132: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #133: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #134: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #135: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #136: -- Full Compiler -- ------------- #137: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #138: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #139: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #140: -- Fast Compiler -- ------------- #141: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #142: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #143: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #144: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #145: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #146: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #147: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #148: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #149: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #150: -- Type.hs: -- //./Type.hs// #151: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #152: module Main where #153: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #154: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #155: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #156: -- Main -- ---- #157: data RunMode = Normalize | Collapse | Search deriving Eq #158: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #159: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #160: -- CLI Commands -- ------------ #161: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #162: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #163: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #164: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #165: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #166: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #167: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #168: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #169: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #170: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #171: -- Prints total time end <- getCPUTime #172: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #173: -- Finalize hvmFree return $ Right () #174: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #175: module HVML.Type where #176: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #177: -- Core Types -- ---------- #178: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #179: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #180: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #181: type Func = ([String], Core) #182: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #183: -- Runtime Types -- ------------- #184: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #185: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #186: type HVM = IO #187: type ReduceAt = Book -> Loc -> HVM Term #188: -- C Functions -- ----------- #189: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #190: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #191: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #192: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #193: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #194: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #195: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #196: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #197: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #198: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #199: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #200: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #201: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #202: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #203: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #204: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #205: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #235: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #236: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #237: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #238: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #239: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #240: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #241: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #242: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #243: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #244: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #245: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #246: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #247: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #248: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #249: -- Constants -- --------- #250: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #251: _DP0_ :: Tag _DP0_ = 0x00 #252: _DP1_ :: Tag _DP1_ = 0x01 #253: _VAR_ :: Tag _VAR_ = 0x02 #254: _SUB_ :: Tag _SUB_ = 0x03 #255: _REF_ :: Tag _REF_ = 0x04 #256: _LET_ :: Tag _LET_ = 0x05 #257: _APP_ :: Tag _APP_ = 0x06 #258: _ANN_ :: Tag _ANN_ = 0x07 #259: _MAT_ :: Tag _MAT_ = 0x08 #260: _OPX_ :: Tag _OPX_ = 0x09 #261: _OPY_ :: Tag _OPY_ = 0x0A #262: _ERA_ :: Tag _ERA_ = 0x0B #263: _LAM_ :: Tag _LAM_ = 0x0C #264: _SUP_ :: Tag _SUP_ = 0x0D #265: _TYP_ :: Tag _TYP_ = 0x0E #266: _CTR_ :: Tag _CTR_ = 0x0F #267: _W32_ :: Tag _W32_ = 0x10 #268: _CHR_ :: Tag _CHR_ = 0x11 #269: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #270: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key #271: -- Primitive Functions _DUP_F_ :: Lab _DUP_F_ = 0xFFF #272: _SUP_F_ :: Lab _SUP_F_ = 0xFFE #273: primitives :: [(String, Lab)] primitives = [ ("SUP", _SUP_F_) , ("DUP", _DUP_F_) ] ./Runtime.c #274: //./Type.hs// //./Reduce.hs// #275: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #276: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #277: typedef _Atomic(Term) ATerm; #278: // Runtime Types // ------------- #279: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[4096])(Term); // functions } State; #280: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #281: // Constants // --------- #282: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #283: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #284: #define SUP_F 0xFFE #define DUP_F 0xFFF #285: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #286: #define VOID 0x00000000000000 #287: // Heap // ---- #288: Loc get_len() { return *HVM.size; } #289: u64 get_itr() { return *HVM.itrs; } #290: void set_len(Loc value) { *HVM.size = value; } #291: void set_itr(Loc value) { *HVM.itrs = value; } #292: // Terms // ------ #293: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #294: Tag term_tag(Term x) { return x & 0x7F; } #295: Tag term_bit(Term x) { return (x >> 7) & 1; } #296: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #297: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #298: Term term_set_bit(Term term) { return term | (1ULL << 7); } #299: // u12v2 // ----- #300: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #301: u64 u12v2_x(u64 u12v2) { return u12v2 & 0xFFF; } #302: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #303: // Atomics // ------- #304: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #305: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #306: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #307: Term take(Loc loc) { return swap(loc, VOID); } #308: // Allocation // ---------- #309: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #310: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #311: // Stringification // --------------- #312: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #313: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #314: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #315: // Evaluation // ---------- #316: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #317: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #318: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #319: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #320: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #321: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #322: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #323: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #324: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #325: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #326: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #327: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #328: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #329: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #330: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #331: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #332: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #333: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #334: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #335: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #336: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #337: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #338: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #339: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #340: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #341: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #342: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #343: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #344: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #345: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #346: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #347: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #348: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #349: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #350: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #351: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #352: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #353: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #354: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #355: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #356: // Primitives // ---------- #357: // Primitive: Dynamic Sup `@SUP(lab tm0 tm1)` // Allocates a new SUP node with given label. Term SUP_f(Term ref) { Loc ref_loc = term_loc(ref); Term lab = got(ref_loc + 0); Term tm0 = got(ref_loc + 1); Term tm1 = got(ref_loc + 2); Loc sup = alloc_node(2); Term ret = term_new(SUP, term_loc(reduce(lab)), sup); set(sup + 0, tm0); set(sup + 1, tm1); return ret; } #358: // TODO Term DUP_f(Term ref) { printf("TODO: Dynamic Dups\n"); exit(0); } #359: // Runtime Memory // -------------- #360: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; HVM.book[SUP_F] = SUP_f; HVM.book[DUP_F] = DUP_f; } #361: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #362: State* hvm_get_state() { return &HVM; } #363: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 4096; i++) { HVM.book[i] = hvm->book[i]; } } #364: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #365: -- //./Type.hs// -- //./Inject.hs// #366: module HVML.Extract where #367: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #368: import Debug.Trace #369: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #370: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #371: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #372: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #373: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #374: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #375: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #376: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #377: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #378: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #379: -- Lifting Dups -- ------------ #380: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #381: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #382: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #383: module HVML.Equal where #384: import Control.Monad (liftM2) import HVML.Type import HVML.Show #385: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #386: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #387: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #388: -- //./Type.hs// #389: module HVML.Inject where #390: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #391: type InjectM a = StateT InjectState HVM a #392: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #393: emptyState :: InjectState emptyState = InjectState Map.empty [] #394: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #395: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #396: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #397: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #398: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #399: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #400: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #401: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #402: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #403: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #404: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #405: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #406: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #407: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #408: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #409: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

df757d9ac1890f0e137cc557af657940f9b418fc

incorporate interaction type theory / experimental

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #26: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #28: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #29: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #30: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #31: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #32: -- Sup Collapser -- ------------- #33: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Chr val -> return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #34: -- Flattener -- --------- #35: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #36: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #37: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #38: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #39: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #40: -- Core Collapser -- -------------- #41: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #42: module HVML.Show where #43: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #44: -- Core Stringification -- -------------------- #45: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #46: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #47: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #48: -- Runtime Stringification -- ----------------------- #49: tagToString :: Tag -> String tagToString t = show (tagT t) #50: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #51: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #52: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #53: -- Pretty Printers -- --------------- #54: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core #55: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #56: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #57: -- Dumping -- ------- #58: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #59: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #60: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #61: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #62: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #63: -- //./Type.hs// #64: module HVML.Parse where #65: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #66: -- Core Parsers -- ------------ #67: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #68: type ParserM = Parsec String ParserState #69: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #70: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #71: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #72: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #73: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #74: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #75: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #76: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #77: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #78: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #79: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #80: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #81: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #82: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #83: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #84: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #85: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #86: -- Helper Parsers -- -------------- #87: consume :: String -> ParserM String consume str = spaces >> string str #88: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #89: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #90: -- Adjusting -- --------- #91: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #92: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #93: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #94: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #95: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #96: -- Errors -- ------ #97: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #98: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #99: -- //./Type.hs// #100: module HVML.Reduce where #101: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #102: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #103: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #104: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #105: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #106: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #107: -- //./Type.hs// #108: module HVML.Compile where #109: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #110: import Debug.Trace #111: -- Compilation -- ----------- #112: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #113: type Compile = State CompileState #114: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #115: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #116: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #117: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #118: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #119: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #120: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #121: -- Full Compiler -- ------------- #122: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #123: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #124: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #125: -- Fast Compiler -- ------------- #126: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #127: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #128: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #129: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #130: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #131: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #132: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #133: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #134: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #135: -- Type.hs: -- //./Type.hs// #136: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #137: module Main where #138: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #139: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #140: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #141: -- Main -- ---- #142: data RunMode = Normalize | Collapse | Search deriving Eq #143: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #144: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #145: -- CLI Commands -- ------------ #146: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #147: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #148: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #149: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #150: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #151: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #152: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #153: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #154: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #155: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #156: -- Prints total time end <- getCPUTime #157: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #158: -- Finalize hvmFree return $ Right () #159: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #160: -- //./Runtime.c// #161: module HVML.Type where #162: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #163: -- Core Types -- ---------- #164: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Chr Char | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #165: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #166: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #167: type Func = ([String], Core) #168: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #169: -- Runtime Types -- ------------- #170: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #171: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #172: type HVM = IO #173: type ReduceAt = Book -> Loc -> HVM Term #174: -- C Functions -- ----------- #175: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #176: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #177: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #178: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #179: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #180: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #181: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #182: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #183: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #184: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #185: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #186: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #187: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #188: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #189: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #190: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #191: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #219: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #220: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #221: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #222: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #223: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #224: -- Constants -- --------- #225: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT 0x0F = CHR tagT tag = error $ "unknown tag: " ++ show tag #226: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_, _CHR_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E _CHR_ = 0x0F #227: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #228: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key ./Runtime.c #229: //./Type.hs// #230: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #231: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #232: typedef _Atomic(Term) ATerm; #233: // Runtime Types // ------------- #234: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #235: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #236: // Constants // --------- #237: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #define CHR 0x0F #238: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #239: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #240: #define VOID 0x00000000000000 #241: // Heap // ---- #242: Loc get_len() { return *HVM.size; } #243: u64 get_itr() { return *HVM.itrs; } #244: void set_len(Loc value) { *HVM.size = value; } #245: void set_itr(Loc value) { *HVM.itrs = value; } #246: // Terms // ------ #247: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #248: Tag term_tag(Term x) { return x & 0x7F; } #249: Tag term_bit(Term x) { return (x >> 7) & 1; } #250: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #251: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #252: Term term_set_bit(Term term) { return term | (1ULL << 7); } #253: // u12v2 // ----- #254: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #255: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #256: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #257: // Atomics // ------- #258: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #259: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #260: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #261: Term take(Loc loc) { return swap(loc, VOID); } #262: // Allocation // ---------- #263: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #264: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #265: // Stringification // --------------- #266: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #267: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #268: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #269: // Evaluation // ---------- #270: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #271: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #272: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #273: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #274: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #275: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #276: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #277: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #278: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #279: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #280: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #281: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #282: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #283: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #284: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #285: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #286: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #287: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #288: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #289: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #290: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #291: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #292: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #293: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #294: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #295: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #296: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #297: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #298: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #299: // Runtime Memory // -------------- #300: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #301: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #302: State* hvm_get_state() { return &HVM; } #303: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #304: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #305: -- //./Type.hs// #306: module HVML.Extract where #307: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #308: import Debug.Trace #309: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #310: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #311: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #312: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #313: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #314: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #315: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #316: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #317: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #318: -- Lifting Dups -- ------------ #319: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Chr val) = return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #320: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #321: module HVML.Inject where #322: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #323: type InjectM a = StateT InjectState HVM a #324: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #325: emptyState :: InjectState emptyState = InjectState Map.empty [] #326: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #327: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #328: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #329: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #330: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #331: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #332: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #333: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #334: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #335: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #336: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #337: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #338: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #339: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.Exit (exitFailure) import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: TYP -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Typ name bod0 #20: ANN -> do let loc = termLoc term val0 <- collapseDupsAt state reduceAt book (loc + 0) typ0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Ann val0 typ0 #21: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #22: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #23: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #24: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #25: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #26: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #27: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) #28: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #29: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #30: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #31: tag -> do putStrLn ("unexpected-tag:" ++ show tag) exitFailure #32: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #33: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #34: -- Sup Collapser -- ------------- #35: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Typ nam bod -> do body <- collapseSups book bod return $ Typ nam body Ann val typ -> do val <- collapseSups book val typ <- collapseSups book typ return $ Ann val typ Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> do return $ U32 val Chr val -> do return $ Chr val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #36: -- Tree Collapser -- -------------- #37: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM (Collapse Core) doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ collapseSups book core #38: -- Flattener -- --------- #39: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #40: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #41: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #42: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #43: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #44: -- Flat Collapser -- -------------- #45: doCollapseFlatAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseFlatAt reduceAt book host = do coll <- doCollapseAt reduceAt book host return $ flatten coll ./Show.hs #46: -- //./Type.hs// #47: module HVML.Show where #48: import Control.Applicative ((<|>)) import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #49: -- Core Stringification -- -------------------- #50: coreToString :: Core -> String coreToString core = case pretty core of Just str -> str Nothing -> case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Typ nam typ -> "%" ++ nam ++ " " ++ coreToString typ Ann val typ -> "{" ++ coreToString val ++ " :: " ++ coreToString typ ++ "}" Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Chr val -> "'" ++ [val] ++ "'" Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #51: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #52: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #53: -- Runtime Stringification -- ----------------------- #54: tagToString :: Tag -> String tagToString t = show (tagT t) #55: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #56: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #57: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #58: -- Pretty Printers -- --------------- #59: pretty :: Core -> Maybe String pretty core = prettyStr core <|> prettyLst core #60: prettyStr :: Core -> Maybe String prettyStr (Ctr 0 []) = Just "\"\"" prettyStr (Ctr 1 [Chr h, t]) = do rest <- prettyStr t return $ "\"" ++ h : tail rest prettyStr _ = Nothing #61: prettyLst :: Core -> Maybe String prettyLst (Ctr 0 []) = Just "[]" prettyLst (Ctr 1 [x, xs]) = do rest <- prettyLst xs return $ "[" ++ coreToString x ++ if rest == "[]" then "]" else " " ++ tail rest prettyLst _ = Nothing #62: -- Dumping -- ------- #63: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #64: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #65: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #66: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #67: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #68: -- //./Type.hs// #69: module HVML.Parse where #70: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import System.Exit (exitFailure) import System.IO.Unsafe (unsafePerformIO) import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #71: -- Core Parsers -- ------------ #72: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #73: type ParserM = Parsec String ParserState #74: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> do parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" nam <- parseName typ <- parseCore return $ Typ nam typ '{' -> do consume "{" val <- parseCore consume "::" typ <- parseCore consume "}" return $ Ann val typ '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat '[' -> parseLst '\'' -> parseChr '"' -> parseStr _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #75: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #76: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #77: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #78: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #79: parseEscapedChar :: ParserM Char parseEscapedChar = choice [ try $ do char '\\' c <- oneOf "\\\"nrtbf0/\'" return $ case c of '\\' -> '\\' '/' -> '/' '"' -> '"' '\'' -> '\'' 'n' -> '\n' 'r' -> '\r' 't' -> '\t' 'b' -> '\b' 'f' -> '\f' '0' -> '\0' , try $ do string "\\u" code <- count 4 hexDigit return $ toEnum (read ("0x" ++ code) :: Int) , noneOf "\"\\" ] #80: parseChr :: ParserM Core parseChr = do skip char '\'' c <- parseEscapedChar char '\'' return $ Chr c #81: parseStr :: ParserM Core parseStr = do skip char '"' str <- many (noneOf "\"") char '"' return $ foldr (\c acc -> Ctr 1 [Chr c, acc]) (Ctr 0 []) str #82: parseLst :: ParserM Core parseLst = do skip char '[' elems <- many $ do closeWith "]" parseCore char ']' return $ foldr (\x acc -> Ctr 1 [x, acc]) (Ctr 0 []) elems #83: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #84: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #85: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #86: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #87: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #88: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #89: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #90: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #91: -- Helper Parsers -- -------------- #92: consume :: String -> ParserM String consume str = spaces >> string str #93: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #94: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #95: -- Adjusting -- --------- #96: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (mget nameToId' name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #97: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Typ x t -> Typ x (setRefIds fids t) Ann x t -> Ann (setRefIds fids x) (setRefIds fids t) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Chr c -> Chr c Era -> Era Ref nam _ arg -> case MS.lookup nam fids of Just fid -> Ref nam fid (map (setRefIds fids) arg) Nothing -> unsafePerformIO $ do putStrLn $ "error:unbound-ref @" ++ nam exitFailure #98: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #99: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #100: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Typ nam typ -> do typ <- go typ ctx return $ Typ nam typ Ann val typ -> do val <- go val ctx typ <- go typ ctx return $ Ann val typ Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Chr c -> return $ Chr c Era -> return Era #101: -- Errors -- ------ #102: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #103: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #104: -- //./Type.hs// #105: module HVML.Reduce where #106: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #107: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) TYP -> cont host (reduceAppTyp term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) CHR -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) TYP -> cont host (reduceDupTyp term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) CHR -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host ANN -> do typ <- reduceAt debug book (loc + 1) case tagT (termTag typ) of ERA -> cont host (reduceAnnEra term typ) LAM -> cont host (reduceAnnLam term typ) SUP -> cont host (reduceAnnSup term typ) TYP -> cont host (reduceAnnTyp term typ) CTR -> cont host (reduceAnnCtr term typ) W32 -> cont host (reduceAnnW32 term typ) CHR -> cont host (reduceAnnW32 term typ) _ -> set (loc + 1) typ >> return term MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) TYP -> cont host (reduceMatTyp term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) CHR -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) TYP -> cont host (reduceOpxTyp term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) CHR -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) TYP -> cont host (reduceOpyTyp term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) CHR -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do reduceRefAt book host reduceAt debug book host -- REF -> do -- let fid = u12v2X lab -- let ari = u12v2Y lab -- case MS.lookup fid (idToFunc book) of -- Just (nams, core) -> do -- incItr -- when (length nams /= fromIntegral ari) $ do -- putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." -- exitFailure -- args <- if ari == 0 -- then return [] -- else mapM (\i -> got (loc + i)) [0 .. ari - 1] -- doInjectCoreAt book core host $ zip nams args -- reduceAt debug book host -- Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #108: -- TODO: move REf logic to this fn reduceRefAt :: Book -> Loc -> HVM Term reduceRefAt book host = do term <- got host let lab = termLab term let loc = termLoc term let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ mget (idToName book) fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args Nothing -> do error $ "unbound-function-id:" ++ show fid #109: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #110: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #111: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #112: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #113: -- //./Type.hs// -- //./Inject.hs// #114: module HVML.Compile where #115: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #116: import Debug.Trace #117: -- Compilation -- ----------- #118: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #119: type Compile = State CompileState #120: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #121: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (mget (idToFunc book) fid) in let core = snd (mget (idToFunc book) fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #122: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #123: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #124: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #125: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #126: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #127: -- Full Compiler -- ------------- #128: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #129: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #130: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Typ var bod) host = do typNam <- fresh "typ" emit $ "Loc " ++ typNam ++ " = alloc_node(2);" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFullCore book fid bod (typNam ++ " + 1") emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFullCore book fid (Ann val typ) host = do annNam <- fresh "ann" emit $ "Loc " ++ annNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (annNam ++ " + 0") typT <- compileFullCore book fid typ (annNam ++ " + 1") emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Chr val) _ = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #131: -- Fast Compiler -- ------------- #132: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #133: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #134: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag("++valNam++") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ mget (idToName book) rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #135: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ mget (idToName book) fid ++ "_t(ref);" #136: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #137: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do return $ "alloc_node(" ++ show arity ++ ")" -- FIXME: temporarily disabled, caused bug in: -- data List { -- #Nil -- #Cons{head tail} -- } -- @cat(xs ys) = ~xs !ys { -- #Nil: ys -- #Cons{h t}: #Cons{h @cat(t ys)} -- } -- @main = @cat(#Cons{1 #Nil} #Nil) -- case MS.lookup arity reuse of -- Just (loc:locs) -> return loc -- _ -> return $ "alloc_node(" ++ show arity ++ ")" #138: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag("++valNam++") == W32 || term_tag("++valNam++") == CHR) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Typ var bod) reuse = do typNam <- fresh "typ" typLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ typNam ++ " = " ++ typLoc ++ ";" emit $ "set(" ++ typNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ typNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ typNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(TYP, 0, " ++ typNam ++ ")" compileFastCore book fid (Ann val typ) reuse = do annNam <- fresh "ann" annLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ annNam ++ " = " ++ annLoc ++ ";" valT <- compileFastCore book fid val reuse typT <- compileFastCore book fid typ reuse emit $ "set(" ++ annNam ++ " + 0, " ++ valT ++ ");" emit $ "set(" ++ annNam ++ " + 1, " ++ typT ++ ");" return $ "term_new(ANN, 0, " ++ annNam ++ ")" compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Chr val) reuse = return $ "term_new(CHR, 0, " ++ show (fromEnum val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #139: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #140: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ mget (idToName book) fid ++ "_f(Term ref) {" emit $ " return " ++ mget (idToName book) fid ++ "_t(ref);" emit $ "}" ./Main.hs #141: -- Type.hs: -- //./Type.hs// #142: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #143: module Main where #144: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #145: import HVML.Collapse import HVML.Compile import HVML.Equal import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #146: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #147: -- Main -- ---- #148: data RunMode = Normalize | Collapse | Search deriving Eq #149: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let typed = "-t" `elem` args let search = "-S" `elem` args let stats = "-s" `elem` args let debug = "-d" `elem` args let mode | collapse = Collapse | search = Search | otherwise = Normalize cliRun file typed debug compiled mode stats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #150: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> # Evals main" putStrLn " -t # Returns the type (experimental)" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #151: -- CLI Commands -- ------------ #152: cliRun :: FilePath -> Bool -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath typed debug compiled mode showStats = do -- Initialize the HVM hvmInit #153: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #154: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #155: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #156: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (mget (idToName book) fid ++ "_f") hvmDefine fid funPtr #157: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #158: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #159: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (mget (nameToId book) "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseFlatAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #160: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> do putStrLn $ coreToString term when typed $ do chk <- check term if chk then do putStrLn "✓ check" else do putStrLn "✗ error" #161: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #162: -- Prints total time end <- getCPUTime #163: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #164: -- Finalize hvmFree return $ Right () #165: genMain :: Book -> String genMain book = let mainFid = mget (nameToId book) "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ mget (idToName book) fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #166: module HVML.Type where #167: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #168: -- Core Types -- ---------- #169: data Core = Var String -- x | Ref String Word64 [Core] -- @fn | Era -- * | Lam String Core -- λx(F) | App Core Core -- (f x) | Sup Word64 Core Core -- &L{a b} | Dup Word64 String String Core Core -- ! &L{a b} = v body | Typ String Core -- %x(T) | Ann Core Core -- {v:T} | Ctr Word64 [Core] -- #Ctr{a b ...} | Mat Core [(String,Core)] [(String,[String],Core)] -- ~ v { #A{a b ...}: ... #B{a b ...}: ... ... } | U32 Word32 -- 123 | Chr Char -- 'a' | Op2 Oper Core Core -- (+ a b) | Let Mode String Core Core -- ! x = v body deriving (Show, Eq) #170: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #171: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #172: type Func = ([String], Core) #173: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #174: -- Runtime Types -- ------------- #175: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #176: data TAG = DP0 | DP1 | VAR | ERA | APP | LAM | SUP | TYP | ANN | SUB | REF | LET | CTR | MAT | W32 | CHR | OPX | OPY deriving (Eq, Show) #177: type HVM = IO #178: type ReduceAt = Book -> Loc -> HVM Term #179: -- C Functions -- ----------- #180: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #181: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #182: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #183: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #184: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #185: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #186: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #187: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #188: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #189: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #190: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #191: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #192: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #193: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #194: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #195: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #196: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_app_typ" reduceAppTyp :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_dup_typ" reduceDupTyp :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #212: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #213: foreign import ccall unsafe "Runtime.c reduce_mat_typ" reduceMatTyp :: Term -> Term -> IO Term #214: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #215: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #216: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #217: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #218: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #219: foreign import ccall unsafe "Runtime.c reduce_opx_typ" reduceOpxTyp :: Term -> Term -> IO Term #220: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #221: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #222: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #223: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #224: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #225: foreign import ccall unsafe "Runtime.c reduce_opy_typ" reduceOpyTyp :: Term -> Term -> IO Term #226: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #227: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #228: foreign import ccall unsafe "Runtime.c reduce_ann_era" reduceAnnEra :: Term -> Term -> IO Term #229: foreign import ccall unsafe "Runtime.c reduce_ann_lam" reduceAnnLam :: Term -> Term -> IO Term #230: foreign import ccall unsafe "Runtime.c reduce_ann_sup" reduceAnnSup :: Term -> Term -> IO Term #231: foreign import ccall unsafe "Runtime.c reduce_ann_typ" reduceAnnTyp :: Term -> Term -> IO Term #232: foreign import ccall unsafe "Runtime.c reduce_ann_ctr" reduceAnnCtr :: Term -> Term -> IO Term #233: foreign import ccall unsafe "Runtime.c reduce_ann_w32" reduceAnnW32 :: Term -> Term -> IO Term #234: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #235: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #236: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #237: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #238: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #239: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #240: -- Constants -- --------- #241: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = ANN tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = TYP tagT 0x0F = CTR tagT 0x10 = W32 tagT 0x11 = CHR tagT tag = error $ "unknown tag: " ++ show tag #242: _DP0_ :: Tag _DP0_ = 0x00 #243: _DP1_ :: Tag _DP1_ = 0x01 #244: _VAR_ :: Tag _VAR_ = 0x02 #245: _SUB_ :: Tag _SUB_ = 0x03 #246: _REF_ :: Tag _REF_ = 0x04 #247: _LET_ :: Tag _LET_ = 0x05 #248: _APP_ :: Tag _APP_ = 0x06 #249: _ANN_ :: Tag _ANN_ = 0x07 #250: _MAT_ :: Tag _MAT_ = 0x08 #251: _OPX_ :: Tag _OPX_ = 0x09 #252: _OPY_ :: Tag _OPY_ = 0x0A #253: _ERA_ :: Tag _ERA_ = 0x0B #254: _LAM_ :: Tag _LAM_ = 0x0C #255: _SUP_ :: Tag _SUP_ = 0x0D #256: _TYP_ :: Tag _TYP_ = 0x0E #257: _CTR_ :: Tag _CTR_ = 0x0F #258: _W32_ :: Tag _W32_ = 0x10 #259: _CHR_ :: Tag _CHR_ = 0x11 #260: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode #261: -- Getter function for maps mget map key = case MS.lookup key map of Just val -> val Nothing -> error $ "key not found: " ++ show key ./Runtime.c #262: //./Type.hs// #263: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #264: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #265: typedef _Atomic(Term) ATerm; #266: // Runtime Types // ------------- #267: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #268: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #269: // Constants // --------- #270: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define ANN 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define TYP 0x0E #define CTR 0x0F #define W32 0x10 #define CHR 0x11 #271: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #272: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #273: #define VOID 0x00000000000000 #274: // Heap // ---- #275: Loc get_len() { return *HVM.size; } #276: u64 get_itr() { return *HVM.itrs; } #277: void set_len(Loc value) { *HVM.size = value; } #278: void set_itr(Loc value) { *HVM.itrs = value; } #279: // Terms // ------ #280: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #281: Tag term_tag(Term x) { return x & 0x7F; } #282: Tag term_bit(Term x) { return (x >> 7) & 1; } #283: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #284: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #285: Term term_set_bit(Term term) { return term | (1ULL << 7); } #286: // u12v2 // ----- #287: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #288: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #289: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #290: // Atomics // ------- #291: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #292: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #293: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #294: Term take(Loc loc) { return swap(loc, VOID); } #295: // Allocation // ---------- #296: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #297: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #298: // Stringification // --------------- #299: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case LAM: printf("LAM"); break; case TYP: printf("TYP"); break; case ANN: printf("ANN"); break; case ERA: printf("ERA"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case CHR: printf("CHR"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #300: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #301: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #302: // Evaluation // ---------- #303: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #304: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #305: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #306: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #307: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #308: // (%x(F) a) // ----------- APP-TYP // x <- λk(y) // %y(F <k:a>) Term reduce_app_typ(Term app, Term typ) { //printf("reduce_app_typ "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc typ_loc = term_loc(typ); Term arg = got(app_loc + 1); Term bod = got(typ_loc + 1); Loc ap0 = app_loc; Loc lm0 = alloc_node(2); Loc an0 = alloc_node(2); Loc ty0 = alloc_node(2); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(VAR, 0, lm0)); set(an0 + 1, arg); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(APP, 0, ap0)); set(ap0 + 0, bod); set(ap0 + 1, term_new(ANN, 0, an0)); set(typ_loc + 0, term_new(LAM, 0, lm0)); return term_new(TYP, 0, ty0); } #309: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #310: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #311: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #312: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #313: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #314: // ! &L{a b} = %x(T) // ----------------- DUP-TYP // a <- %x0(t0) // b <- %x1(t1) // x <- &L{x0 x1} // ! &L{t0 t1} = T Term reduce_dup_typ(Term dup, Term typ) { //printf("reduce_dup_typ "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc typ_loc = term_loc(typ); Term bod = got(typ_loc + 1); Loc du0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ty1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(DP0, dup_lab, du0)); set(ty1 + 0, term_new(SUB, 0, 0)); set(ty1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, ty0)); set(su0 + 1, term_new(VAR, 0, ty1)); set(dup_loc + 0, term_new(TYP, 0, ty0)); set(dup_loc + 1, term_new(TYP, 0, ty1)); set(typ_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #315: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #316: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #317: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #318: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #319: // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #320: // ~ %x(T) {K0 K1 K2 ...} // ---------------------- MAT-TYP // ⊥ Term reduce_mat_typ(Term mat, Term sup) { printf("invalid:mat-typ\n"); exit(0); } #321: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #322: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Lab mat_tag = term_tag(mat); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #323: // <op(* b) // -------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #324: // <op(λx(B) y) // ------------ OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #325: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #326: // <op(%x(T) y) // ------------ OPX-TYP // ⊥ Term reduce_opx_typ(Term opx, Term typ) { printf("invalid:opx-typ"); exit(0); } #327: // <op(#{x0 x1 x2...} y) // --------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #328: // <op(x0 x1) // ---------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #329: // >op(a *) // -------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #330: // >op(a λx(B)) // ------------ OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #331: // >op(a &L{x y}) // --------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #332: // >op(%x(T) y) // ------------ OPY-TYP // ⊥ Term reduce_opy_typ(Term opy, Term typ) { printf("invalid:opy-typ"); exit(0); } #333: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #334: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 t = term_tag(w32); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(t, 0, result); } #335: // <v : *> // -------------- ANN-ERA // * Term reduce_ann_era(Term ann, Term era) { inc_itr(); return era; } #336: // <v : λx(T)> // -------------- ANN-LAM // x <- %k(y) // λy <(v k) : T> Term reduce_ann_lam(Term ann, Term lam) { //printf("reduce_ann_lam "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc lam_loc = term_loc(lam); Term val = got(ann_loc + 0); Term typ = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc ty0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc an0 = ann_loc; set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(ANN, 0, an0)); set(ty0 + 0, term_new(SUB, 0, 0)); set(ty0 + 1, term_new(VAR, 0, lm0)); set(ap0 + 0, val); set(ap0 + 1, term_new(VAR, 0, ty0)); set(an0 + 0, term_new(APP, 0, ap0)); set(an0 + 1, typ); set(lam_loc + 0, term_new(TYP, 0, ty0)); return term_new(LAM, 0, lm0); } #337: // <v : &L{a b}> // -------------- ANN-SUP // ! &L{v0 v1} = v // &L{<v0:a> <v1:b>} Term reduce_ann_sup(Term ann, Term sup) { //printf("reduce_ann_sup "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term val = got(ann_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); Loc an0 = alloc_node(2); Loc su0 = alloc_node(2); Loc an1 = ann_loc; set(du0 + 0, val); set(du0 + 1, term_new(SUB, 0, 0)); set(an0 + 0, term_new(DP0, sup_lab, du0)); set(an0 + 1, tm0); set(an1 + 0, term_new(DP1, sup_lab, du0)); set(an1 + 1, tm1); set(su0 + 0, term_new(ANN, 0, an0)); set(su0 + 1, term_new(ANN, 0, an1)); return term_new(SUP, sup_lab, su0); } #338: // <v : %x(T)> // ----------- ANN-TYP // x <- v // T Term reduce_ann_typ(Term ann, Term typ) { //printf("reduce_ann_typ "); print_term(ann); printf("\n"); inc_itr(); Loc ann_loc = term_loc(ann); Loc typ_loc = term_loc(typ); Term val = got(ann_loc + 0); Term bod = got(typ_loc + 1); set(typ_loc + 0, val); return bod; } #339: // <v : #{x y z ...}> // ------------------ ANN-CTR // ⊥ Term reduce_ann_ctr(Term ann, Term ctr) { printf("invalid:ann-ctr"); exit(0); } #340: // <v : 123> // --------- ANN-U32 // ⊥ Term reduce_ann_w32(Term ann, Term w32) { printf("invalid:ann-w32"); exit(0); } #341: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case ANN: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case TYP: next = reduce_app_typ(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case CHR: next = reduce_app_w32(prev, next); continue; default: break; } break; } case ANN: { switch (tag) { case ERA: next = reduce_ann_era(prev, next); continue; case LAM: next = reduce_ann_lam(prev, next); continue; case SUP: next = reduce_ann_sup(prev, next); continue; case TYP: next = reduce_ann_typ(prev, next); continue; case CTR: next = reduce_ann_ctr(prev, next); continue; case W32: next = reduce_ann_w32(prev, next); continue; case CHR: next = reduce_ann_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case TYP: next = reduce_dup_typ(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case CHR: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case TYP: next = reduce_mat_typ(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case CHR: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case TYP: next = reduce_opx_typ(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case CHR: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case TYP: next = reduce_opy_typ(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case CHR: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #342: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case TYP: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case ANN: { Term val = got(loc + 0); Term typ = got(loc + 1); val = normal(val); typ = normal(typ); set(loc + 0, val); set(loc + 1, typ); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #343: // Runtime Memory // -------------- #344: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #345: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #346: State* hvm_get_state() { return &HVM; } #347: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #348: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #349: -- //./Type.hs// -- //./Inject.hs// #350: module HVML.Extract where #351: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #352: import Debug.Trace #353: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #354: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #355: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #356: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #357: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #358: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 #359: TYP -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Typ name bod ANN -> do let loc = termLoc term val <- extractCoreAt state reduceAt book (loc + 0) typ <- extractCoreAt state reduceAt book (loc + 1) return $ Ann val typ VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #360: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #361: CHR -> do let val = termLoc term return $ Chr (chr (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #362: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #363: -- Lifting Dups -- ------------ #364: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Typ nam bod) = do bod <- liftDups bod return $ Typ nam bod liftDups (Ann val typ) = do val <- liftDups val typ <- liftDups typ return $ Ann val typ liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = do return $ U32 val liftDups (Chr val) = do return $ Chr val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #365: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Equal.hs #366: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// -- //./Collapse.hs// #367: module HVML.Equal where #368: import Control.Monad (liftM2) import HVML.Type import HVML.Show #369: equal :: Core -> Core -> HVM Bool equal a b = do -- putStrLn $ "eq " ++ coreToString a ++ "\n== " ++ coreToString b same a b #370: same (Var aNam) (Var bNam) = do return $ aNam == bNam same (App aFun aArg) (App bFun bArg) = do eFun <- equal aFun bFun eArg <- equal aArg bArg return $ eFun && eArg same (Lam aNam aBod) (Lam bNam bBod) = do equal aBod bBod same Era Era = do return True same (Sup aLab aA aB) (Sup bLab bA bB) = do error "unreachable" same (Dup aLab aX aY aVal aBod) (Dup bLab bX bY bVal bBod) = do error "unreachable" same (Typ aNam aBod) (Typ bNam bBod) = do error "unreachable" same (Ann aVal aTyp) (Ann bVal bTyp) = do equal aVal bVal same (Ctr aCid aArgs) (Ctr bCid bArgs) | aCid /= bCid = return False | length aArgs /= length bArgs = return False | otherwise = do results <- sequence $ zipWith equal aArgs bArgs return $ and results same (Mat aVal aCses aAlts) (Mat bVal bCses bAlts) | length aCses /= length bCses || length aAlts /= length bAlts = return False | otherwise = do eVal <- equal aVal bVal eCses <- sequence [equal av bv | ((ak,av),(bk,bv)) <- zip aCses bCses, ak == bk] eAlts <- sequence [equal ab bb | ((ac,af,ab),(bc,bf,bb)) <- zip aAlts bAlts, ac == bc && af == bf] return $ eVal && and eCses && and eAlts same (U32 aVal) (U32 bVal) = do return $ aVal == bVal same (Chr aVal) (Chr bVal) = do return $ aVal == bVal same (Op2 aOp aA aB) (Op2 bOp bA bB) | aOp /= bOp = return False | otherwise = liftM2 (&&) (equal aA bA) (equal aB bB) same (Let aMod aNam aVal aBod) (Let bMod bNam bVal bBod) | aMod /= bMod = return False | otherwise = liftM2 (&&) (equal aVal bVal) (equal aBod bBod) same _ _ = do return False #371: check :: Core -> HVM Bool check (Var nam) = do return True check (App fun arg) = do fun <- check fun arg <- check arg return $ fun && arg check (Lam nam bod) = do bod <- check bod return bod check Era = do return True check (Sup lab a b) = do a <- check a b <- check b return $ a && b check (Dup lab x y val bod) = do val <- check val bod <- check bod return $ val && bod check (Typ nam bod) = do bod <- check bod return bod check (Ann val typ) = case val of Ann valVal valTyp -> do eql <- equal typ valTyp val <- check valVal return $ eql && val otherwise -> do return False check (Ctr cid args) = do args <- mapM check args return $ and args check (Mat val cses alts) = do val <- check val cses <- mapM (check . snd) cses alts <- mapM (\(_,_,bod) -> check bod) alts return $ val && and cses && and alts check (U32 val) = do return True check (Chr val) = do return True check (Op2 op a b) = do a <- check a b <- check b return $ a && b check (Let mod nam val bod) = do val <- check val bod <- check bod return $ val && bod ./Inject.hs #372: -- //./Type.hs// #373: module HVML.Inject where #374: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Char (ord) import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #375: type InjectM a = StateT InjectState HVM a #376: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #377: emptyState :: InjectState emptyState = InjectState Map.empty [] #378: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #379: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #380: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #381: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #382: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #383: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #384: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #385: injectCore book (Typ nam bod) loc = do typ <- lift $ allocNode 2 lift $ set (typ + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (typ + 0)) (args s) } injectCore book bod (typ + 1) lift $ set loc (termNew _TYP_ 0 typ) #386: injectCore book (Ann val typ) loc = do ann <- lift $ allocNode 2 injectCore book val (ann + 0) injectCore book typ (ann + 1) lift $ set loc (termNew _ANN_ 0 ann) #387: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #388: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #389: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #390: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #391: injectCore book (Chr val) loc = do lift $ set loc (termNew _CHR_ 0 (fromIntegral $ ord val)) #392: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #393: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

be6610278161dc696f2b2e42fb21ae0fab970ad2

optimizations: dup-tail-call and immediate-call now, when a case returns a dup, such as range below: @range(n xs) = ~n !xs { 0: xs p: !&0{p0 p1}=p @range(p0 #Cons{p1 xs}) } it will still detect it as a tail call also, strict calls, such as: @loop(n t) = ~n !t { 0: t p: !! t = @rots(t) @loop(p t) } will call the C function immediatelly, instead of creating a ref and passing to reduce

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: module HVML.Show where #41: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #42: -- Core Stringification -- -------------------- #43: coreToString :: Core -> String coreToString core = case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #44: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #45: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #46: -- Runtime Stringification -- ----------------------- #47: tagToString :: Tag -> String tagToString t = show (tagT t) #48: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #49: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #50: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #51: -- Dumping -- ------- #52: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #53: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #54: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #55: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #56: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #57: -- //./Type.hs// #58: module HVML.Parse where #59: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #60: -- Core Parsers -- ------------ #61: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #62: type ParserM = Parsec String ParserState #63: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #64: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #65: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #66: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #67: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #68: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #69: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #70: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #71: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #72: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #73: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #74: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #75: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #76: -- Helper Parsers -- -------------- #77: consume :: String -> ParserM String consume str = spaces >> string str #78: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #79: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #80: -- Adjusting -- --------- #81: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #82: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #83: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #84: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #85: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #86: -- Errors -- ------ #87: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #88: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #89: -- //./Type.hs// #90: module HVML.Reduce where #91: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #92: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #93: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #94: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #95: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #96: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #97: -- //./Type.hs// -- //./Inject.hs// #98: module HVML.Compile where #99: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #100: import Debug.Trace #101: -- Compilation -- ----------- #102: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #103: type Compile = State CompileState #104: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #105: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #106: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #107: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #108: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #109: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #110: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #111: -- Full Compiler -- ------------- #112: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #113: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #114: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #115: -- Fast Compiler -- ------------- #116: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #117: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #118: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #119: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #120: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #121: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do case MS.lookup arity reuse of Just (loc:locs) -> return loc _ -> return $ "alloc_node(" ++ show arity ++ ")" #122: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #123: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #124: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #125: -- Type.hs: -- //./Type.hs// #126: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #127: module Main where #128: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #129: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #130: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #131: -- Main -- ---- #132: data RunMode = Normalize | Collapse | Search deriving Eq #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #178: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #179: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #180: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #182: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #209: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #210: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #211: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #212: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #214: -- Constants -- --------- #215: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #216: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #217: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #218: //./Type.hs// #219: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #220: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #221: typedef _Atomic(Term) ATerm; #222: // Runtime Types // ------------- #223: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #224: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #225: // Constants // --------- #226: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #227: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #228: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #229: #define VOID 0x00000000000000 #230: // Heap // ---- #231: Loc get_len() { return *HVM.size; } #232: u64 get_itr() { return *HVM.itrs; } #233: void set_len(Loc value) { *HVM.size = value; } #234: void set_itr(Loc value) { *HVM.itrs = value; } #235: // Terms // ------ #236: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #237: Tag term_tag(Term x) { return x & 0x7F; } #238: Tag term_bit(Term x) { return (x >> 7) & 1; } #239: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #240: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #241: Term term_set_bit(Term term) { return term | (1ULL << 7); } #242: // u12v2 // ----- #243: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #244: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #245: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #246: // Atomics // ------- #247: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #248: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #249: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term take(Loc loc) { return swap(loc, VOID); } #251: // Allocation // ---------- #252: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #253: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #254: // Stringification // --------------- #255: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #256: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #257: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #258: // Evaluation // ---------- #259: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #260: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #261: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #262: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #263: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #264: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #265: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #266: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #267: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #268: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #269: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #271: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #272: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #273: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #274: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #275: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #276: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #277: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #278: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #279: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #280: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #281: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #282: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #283: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #284: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #285: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #286: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #287: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #288: // Runtime Memory // -------------- #289: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #290: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #291: State* hvm_get_state() { return &HVM; } #292: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #293: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #294: -- //./Type.hs// #295: module HVML.Extract where #296: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #297: import Debug.Trace #298: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #299: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #300: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #301: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #302: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #303: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #304: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do print "AAA" let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #305: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #306: -- Lifting Dups -- ------------ #307: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #308: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #309: module HVML.Inject where #310: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #311: type InjectM a = StateT InjectState HVM a #312: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #313: emptyState :: InjectState emptyState = InjectState Map.empty [] #314: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #315: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #316: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #317: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #318: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #319: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #320: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #321: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #322: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #323: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #324: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #325: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #326: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: module HVML.Show where #41: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #42: -- Core Stringification -- -------------------- #43: coreToString :: Core -> String coreToString core = case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #44: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #45: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #46: -- Runtime Stringification -- ----------------------- #47: tagToString :: Tag -> String tagToString t = show (tagT t) #48: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #49: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #50: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #51: -- Dumping -- ------- #52: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #53: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #54: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #55: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #56: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #57: -- //./Type.hs// #58: module HVML.Parse where #59: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #60: -- Core Parsers -- ------------ #61: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #62: type ParserM = Parsec String ParserState #63: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #64: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #65: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #66: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #67: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #68: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #69: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #70: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #71: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #72: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #73: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #74: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #75: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #76: -- Helper Parsers -- -------------- #77: consume :: String -> ParserM String consume str = spaces >> string str #78: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #79: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #80: -- Adjusting -- --------- #81: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #82: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #83: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #84: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #85: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #86: -- Errors -- ------ #87: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #88: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #89: -- //./Type.hs// #90: module HVML.Reduce where #91: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #92: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #93: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #94: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #95: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #96: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #97: -- //./Type.hs// #98: module HVML.Compile where #99: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #100: import Debug.Trace #101: -- Compilation -- ----------- #102: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #103: type Compile = State CompileState #104: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #105: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #106: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #107: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #108: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #109: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #110: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #111: -- Full Compiler -- ------------- #112: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #113: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #114: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #115: -- Fast Compiler -- ------------- #116: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args MS.empty tabDec emit "}" #117: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> MS.Map Int [String] -> Compile () compileFastArgs book fid body ctx reuse = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx False 0 reuse tabDec emit $ "}" #118: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Bool -> Int -> MS.Map Int [String] -> Compile () compileFastBody book fid term@(Mat val mov css) ctx stop@False itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length mov) reuse emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc let reuse' = MS.insertWith (++) (length fds) ["term_loc(" ++ valNam ++ ")"] reuse forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val reuse' bind key valT compileFastBody book fid bod ctx stop (itr + 1 + length fds + length mov) reuse' emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr reuse compileFastBody book fid term@(Dup lab dp0 dp1 val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse valNam <- fresh "val" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupNam <- fresh "dup" dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Let mode var val bod) ctx stop itr reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do case val of Ref _ rFid _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ idToName book MS.! rFid ++ "_f(" ++ valT ++ "));" bind var valNam _ -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastBody book fid bod ctx stop itr reuse compileFastBody book fid term@(Ref fNam fFid fArg) ctx stop itr reuse | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg reuse emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx stop itr reuse = do emit $ "itrs += " ++ show itr ++ ";" body <- compileFastCore book fid term reuse compileFastSave book fid term ctx itr reuse emit $ "return " ++ body ++ ";" #119: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastUndo book fid term ctx itr reuse = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #120: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> MS.Map Int [String] -> Compile () compileFastSave book fid term ctx itr reuse = do emit $ "*HVM.itrs += itrs;" #121: -- Helper function to allocate nodes with reuse compileFastAlloc :: Int -> MS.Map Int [String] -> Compile String compileFastAlloc arity reuse = do case MS.lookup arity reuse of Just (loc:locs) -> return loc _ -> return $ "alloc_node(" ++ show arity ++ ")" #122: -- Compiles a core term in fast mode compileFastCore :: Book -> Word64 -> Core -> MS.Map Int [String] -> Compile String compileFastCore book fid Era reuse = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) reuse = do valT <- compileFastCore book fid val reuse case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod reuse compileFastCore book fid (Var name) reuse = do compileFastVar name compileFastCore book fid (Lam var bod) reuse = do lamNam <- fresh "lam" lamLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ lamNam ++ " = " ++ lamLoc ++ ";" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod reuse emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) reuse = do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" funT <- compileFastCore book fid fun reuse argT <- compileFastCore book fid arg reuse emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) reuse = do supNam <- fresh "sup" supLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ supNam ++ " = " ++ supLoc ++ ";" tm0T <- compileFastCore book fid tm0 reuse tm1T <- compileFastCore book fid tm1 reuse emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) reuse = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val reuse emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc dupLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ dupNam ++ " = " ++ dupLoc ++ ";" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod reuse compileFastCore book fid (Ctr cid fds) reuse = do ctrNam <- fresh "ctr" let arity = length fds ctrLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ ctrNam ++ " = " ++ ctrLoc ++ ";" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd reuse) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) reuse = do matNam <- fresh "mat" let arity = length css matLoc <- compileFastAlloc (1 + arity) reuse emit $ "Loc " ++ matNam ++ " = " ++ matLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' reuse emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" foldM (\term (key, val) -> do appNam <- fresh "app" appLoc <- compileFastAlloc 2 reuse emit $ "Loc " ++ appNam ++ " = " ++ appLoc ++ ";" valT <- compileFastCore book fid val reuse emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFastCore book fid (U32 val) reuse = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) reuse = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 reuse nu1T <- compileFastCore book fid nu1 reuse emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" opxLoc <- compileFastAlloc 2 reuse emit $ " Loc " ++ opxNam ++ " = " ++ opxLoc ++ ";" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) reuse = do refNam <- fresh "ref" let arity = length rArg refLoc <- compileFastAlloc arity reuse emit $ "Loc " ++ refNam ++ " = " ++ refLoc ++ ";" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg reuse) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #123: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #124: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #125: -- Type.hs: -- //./Type.hs// #126: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #127: module Main where #128: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #129: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #130: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #131: -- Main -- ---- #132: data RunMode = Normalize | Collapse | Search deriving Eq #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #178: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #179: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #180: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #182: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #209: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #210: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #211: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #212: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #214: -- Constants -- --------- #215: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #216: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #217: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #218: //./Type.hs// #219: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #220: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #221: typedef _Atomic(Term) ATerm; #222: // Runtime Types // ------------- #223: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #224: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #225: // Constants // --------- #226: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #227: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #228: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #229: #define VOID 0x00000000000000 #230: // Heap // ---- #231: Loc get_len() { return *HVM.size; } #232: u64 get_itr() { return *HVM.itrs; } #233: void set_len(Loc value) { *HVM.size = value; } #234: void set_itr(Loc value) { *HVM.itrs = value; } #235: // Terms // ------ #236: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #237: Tag term_tag(Term x) { return x & 0x7F; } #238: Tag term_bit(Term x) { return (x >> 7) & 1; } #239: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #240: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #241: Term term_set_bit(Term term) { return term | (1ULL << 7); } #242: // u12v2 // ----- #243: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #244: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #245: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #246: // Atomics // ------- #247: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #248: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #249: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term take(Loc loc) { return swap(loc, VOID); } #251: // Allocation // ---------- #252: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #253: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #254: // Stringification // --------------- #255: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #256: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #257: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #258: // Evaluation // ---------- #259: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #260: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #261: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #262: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #263: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #264: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #265: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #266: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #267: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #268: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #269: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #271: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #272: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #273: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #274: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #275: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #276: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #277: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #278: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #279: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #280: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #281: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #282: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #283: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #284: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #285: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #286: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #287: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #288: // Runtime Memory // -------------- #289: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #290: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #291: State* hvm_get_state() { return &HVM; } #292: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #293: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #294: -- //./Type.hs// #295: module HVML.Extract where #296: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #297: import Debug.Trace #298: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #299: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #300: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #301: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #302: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #303: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #304: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do print "AAA" let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #305: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #306: -- Lifting Dups -- ------------ #307: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #308: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #309: module HVML.Inject where #310: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #311: type InjectM a = StateT InjectState HVM a #312: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #313: emptyState :: InjectState emptyState = InjectState Map.empty [] #314: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #315: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #316: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #317: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #318: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #319: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #320: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #321: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #322: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #323: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #324: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #325: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #326: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

67f6e216aaa51b1e705fff34e6f35459e7774ff8

bugfix; 10 billion itr/s single-core! we can not call 'reduce()' inside the hot-path attempt, otherwise this can cause reduce to be called twice on the same term (in cases of undo), which, in turn, can cause duplicated terms in memory. by fixing this, the count.hvml test magically jumps to 10 billion MIPS (about the same performance as Haskell), and the sum_range to 2139 MIPS (almost 6x faster than Haskell!). of course, for the hot paths to kick, we now need to place strict annotations correctly I've also added more memore reuses and the nots.hvml bench is up to 91 MIPS, and the pseudo_metavars_factors.hvml is up to 100 MIPS, which makes it 22x faster than the Haskell equivalent! I've also attempted to introduce a freelist, but it didn't result in significant speedups and I don't think it was worth the extra code and operations. I know I was supposed to rest but I had to do this btw, the new gpt-4o model is really good, it translated a compiled hvm.c file (20K tokens) to JS in a almost single pass, and that allowed me to find this issue

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: module HVML.Show where #41: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #42: -- Core Stringification -- -------------------- #43: coreToString :: Core -> String coreToString core = case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #44: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #45: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #46: -- Runtime Stringification -- ----------------------- #47: tagToString :: Tag -> String tagToString t = show (tagT t) #48: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #49: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #50: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #51: -- Dumping -- ------- #52: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #53: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #54: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #55: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #56: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #57: -- //./Type.hs// #58: module HVML.Parse where #59: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #60: -- Core Parsers -- ------------ #61: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #62: type ParserM = Parsec String ParserState #63: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #64: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #65: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #66: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #67: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #68: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #69: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #70: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #71: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #72: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #73: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #74: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #75: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #76: -- Helper Parsers -- -------------- #77: consume :: String -> ParserM String consume str = spaces >> string str #78: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #79: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #80: -- Adjusting -- --------- #81: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #82: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #83: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #84: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #85: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #86: -- Errors -- ------ #87: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #88: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #89: -- //./Type.hs// #90: module HVML.Reduce where #91: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #92: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #93: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #94: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #95: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #96: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #97: -- //./Type.hs// -- //./Inject.hs// #98: module HVML.Compile where #99: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #100: import Debug.Trace #101: -- Compilation -- ----------- #102: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #103: type Compile = State CompileState #104: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #105: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #106: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #107: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #108: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #109: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #110: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #111: -- Full Compiler -- ------------- #112: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #113: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #114: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #115: -- Fast Compiler -- ------------- #116: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #117: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #118: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val mov css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length mov) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) -- compileFastApps book fid bod args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #119: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #120: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #121: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFastCore book fid val emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov #122: compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #123: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #124: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #125: -- Type.hs: -- //./Type.hs// #126: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #127: module Main where #128: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #129: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #130: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #131: -- Main -- ---- #132: data RunMode = Normalize | Collapse | Search deriving Eq #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #178: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #179: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #180: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #182: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #209: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #210: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #211: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #212: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #214: -- Constants -- --------- #215: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #216: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #217: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #218: //./Type.hs// #219: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #220: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #221: typedef _Atomic(Term) ATerm; #222: // Runtime Types // ------------- #223: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #224: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #225: // Constants // --------- #226: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #227: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #228: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #229: #define VOID 0x00000000000000 #230: // Heap // ---- #231: Loc get_len() { return *HVM.size; } #232: u64 get_itr() { return *HVM.itrs; } #233: void set_len(Loc value) { *HVM.size = value; } #234: void set_itr(Loc value) { *HVM.itrs = value; } #235: // Terms // ------ #236: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #237: Tag term_tag(Term x) { return x & 0x7F; } #238: Tag term_bit(Term x) { return (x >> 7) & 1; } #239: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #240: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #241: Term term_set_bit(Term term) { return term | (1ULL << 7); } #242: // u12v2 // ----- #243: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #244: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #245: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #246: // Atomics // ------- #247: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #248: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #249: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term take(Loc loc) { return swap(loc, VOID); } #251: // Allocation // ---------- #252: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #253: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #254: // Stringification // --------------- #255: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #256: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #257: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #258: // Evaluation // ---------- #259: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #260: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #261: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #262: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #263: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #264: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #265: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #266: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #267: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #268: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #269: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #271: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #272: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #273: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); //Loc mat0 = mat_loc; Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #274: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #275: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #276: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #277: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #278: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #279: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #280: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #281: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #282: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #283: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #284: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #285: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #286: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #287: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #288: // Runtime Memory // -------------- #289: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #290: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #291: State* hvm_get_state() { return &HVM; } #292: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #293: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #294: -- //./Type.hs// #295: module HVML.Extract where #296: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #297: import Debug.Trace #298: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #299: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #300: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #301: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #302: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #303: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #304: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do print "AAA" let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #305: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #306: -- Lifting Dups -- ------------ #307: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #308: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #309: module HVML.Inject where #310: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #311: type InjectM a = StateT InjectState HVM a #312: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #313: emptyState :: InjectState emptyState = InjectState Map.empty [] #314: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #315: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #316: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #317: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #318: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #319: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #320: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #321: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #322: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #323: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #324: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #325: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #326: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: module HVML.Show where #41: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #42: -- Core Stringification -- -------------------- #43: coreToString :: Core -> String coreToString core = case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #44: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #45: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #46: -- Runtime Stringification -- ----------------------- #47: tagToString :: Tag -> String tagToString t = show (tagT t) #48: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #49: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #50: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #51: -- Dumping -- ------- #52: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #53: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #54: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #55: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #56: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #57: -- //./Type.hs// #58: module HVML.Parse where #59: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #60: -- Core Parsers -- ------------ #61: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #62: type ParserM = Parsec String ParserState #63: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #64: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #65: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #66: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #67: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #68: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #69: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #70: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #71: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #72: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #73: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #74: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #75: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #76: -- Helper Parsers -- -------------- #77: consume :: String -> ParserM String consume str = spaces >> string str #78: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #79: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #80: -- Adjusting -- --------- #81: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #82: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #83: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #84: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #85: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #86: -- Errors -- ------ #87: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #88: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #89: -- //./Type.hs// #90: module HVML.Reduce where #91: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #92: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #93: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #94: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #95: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #96: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #97: -- //./Type.hs// -- //./Inject.hs// #98: module HVML.Compile where #99: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #100: import Debug.Trace #101: -- Compilation -- ----------- #102: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #103: type Compile = State CompileState #104: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #105: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #106: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #107: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #108: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #109: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #110: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #111: -- Full Compiler -- ------------- #112: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #113: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #114: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #115: -- Fast Compiler -- ------------- #116: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #117: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #118: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val mov css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length mov) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) -- compileFastApps book fid bod args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #119: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #120: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #121: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFastCore book fid val emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov #122: compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #123: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #124: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #125: -- Type.hs: -- //./Type.hs// #126: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #127: module Main where #128: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #129: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #130: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #131: -- Main -- ---- #132: data RunMode = Normalize | Collapse | Search deriving Eq #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #178: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #179: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #180: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #182: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #209: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #210: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #211: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #212: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #214: -- Constants -- --------- #215: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #216: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #217: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #218: //./Type.hs// #219: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #220: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #221: typedef _Atomic(Term) ATerm; #222: // Runtime Types // ------------- #223: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #224: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #225: // Constants // --------- #226: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #227: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #228: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #229: #define VOID 0x00000000000000 #230: // Heap // ---- #231: Loc get_len() { return *HVM.size; } #232: u64 get_itr() { return *HVM.itrs; } #233: void set_len(Loc value) { *HVM.size = value; } #234: void set_itr(Loc value) { *HVM.itrs = value; } #235: // Terms // ------ #236: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #237: Tag term_tag(Term x) { return x & 0x7F; } #238: Tag term_bit(Term x) { return (x >> 7) & 1; } #239: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #240: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #241: Term term_set_bit(Term term) { return term | (1ULL << 7); } #242: // u12v2 // ----- #243: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #244: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #245: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #246: // Atomics // ------- #247: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #248: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #249: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term take(Loc loc) { return swap(loc, VOID); } #251: // Allocation // ---------- #252: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #253: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #254: // Stringification // --------------- #255: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #256: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #257: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #258: // Evaluation // ---------- #259: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #260: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #261: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #262: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #263: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #264: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #265: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #266: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #267: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #268: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #269: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #271: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #272: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #273: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc mat1 = alloc_node(1 + mat_len); //Loc mat0 = alloc_node(1 + mat_len); //Loc sup0 = alloc_node(2); Loc mat0 = mat_loc; Loc sup0 = sup_loc; set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #274: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #275: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #276: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #277: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #278: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #279: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #280: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #281: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #282: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #283: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #284: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #285: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #286: Term reduce(Term term) { //if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #287: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #288: // Runtime Memory // -------------- #289: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #290: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #291: State* hvm_get_state() { return &HVM; } #292: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #293: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #294: -- //./Type.hs// #295: module HVML.Extract where #296: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #297: import Debug.Trace #298: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #299: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #300: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #301: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #302: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #303: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #304: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do print "AAA" let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #305: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #306: -- Lifting Dups -- ------------ #307: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #308: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #309: module HVML.Inject where #310: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #311: type InjectM a = StateT InjectState HVM a #312: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #313: emptyState :: InjectState emptyState = InjectState Map.empty [] #314: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #315: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #316: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #317: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #318: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #319: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #320: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #321: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #322: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #323: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #324: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #325: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #326: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

43ecd229fc35d41209e7c3274bd5f423ccc6bbba

syntax updates to align with mandatory affinity

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 0) return whnf DP1 -> do normalAtWith reduceAt book (loc + 0) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: data RunMode = Normalize | Collapse | Search deriving Eq #134: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #135: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" return $ Right () #136: -- CLI Commands -- ------------ #137: cliRun :: FilePath -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath compiled mode showStats = do -- Initialize the HVM hvmInit #138: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #139: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #140: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #141: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #142: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #143: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #144: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #145: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #146: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #147: -- Prints total time end <- getCPUTime #148: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #149: -- Finalize hvmFree return $ Right () #150: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #151: -- //./Runtime.c// #152: module HVML.Type where #153: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #154: -- Core Types -- ---------- #155: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #156: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #157: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #158: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #159: type Func = ([String], Core) #160: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #161: -- Runtime Types -- ------------- #162: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #163: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #164: type HVM = IO #165: type ReduceAt = Book -> Loc -> HVM Term #166: -- C Functions -- ----------- #167: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #168: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #169: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #170: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #171: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #173: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #174: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #175: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #176: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #177: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #178: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #179: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #180: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #181: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #183: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #211: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #212: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #213: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #215: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #216: -- Constants -- --------- #217: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #218: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #219: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #220: //./Type.hs// #221: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #222: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #223: typedef _Atomic(Term) ATerm; #224: // Runtime Types // ------------- #225: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #226: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #227: // Constants // --------- #228: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #229: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #230: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #231: #define VOID 0x00000000000000 #232: // Heap // ---- #233: Loc get_len() { return *HVM.size; } #234: u64 get_itr() { return *HVM.itrs; } #235: void set_len(Loc value) { *HVM.size = value; } #236: void set_itr(Loc value) { *HVM.itrs = value; } #237: // Terms // ------ #238: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #239: Tag term_tag(Term x) { return x & 0x7F; } #240: Tag term_bit(Term x) { return (x >> 7) & 1; } #241: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #242: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #250: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); //Loc mat0 = mat_loc; Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do print $ "GOT " ++ name case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- forM aux (collapseDupsAt state reduceAt book) return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term let aux = if len == 0 then [] else [loc + 1 + i | i <- [0..len-1]] val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- forM aux $ \h -> do bod <- collapseDupsAt state reduceAt book h return $ ("#", [], bod) -- TODO: recover constructor and fields return $ Mat val0 [] css0 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val mov css -> do val <- collapseSups book val mov <- mapM (\(key, expr) -> do expr <- collapseSups book expr return (key, expr)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- collapseSups book bod return (ctr, fds, bod)) css return $ Mat val mov css U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: module HVML.Show where #41: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #42: -- Core Stringification -- -------------------- #43: coreToString :: Core -> String coreToString core = case core of Var nam -> nam Era -> "*" Lam vr0 bod -> let bod' = coreToString bod in "λ" ++ vr0 ++ " " ++ bod' App fun arg -> let fun' = coreToString fun in let arg' = coreToString arg in "(" ++ fun' ++ " " ++ arg' ++ ")" Sup lab tm0 tm1 -> let tm0' = coreToString tm0 in let tm1' = coreToString tm1 in "&" ++ show lab ++ "{" ++ tm0' ++ " " ++ tm1' ++ "}" Dup lab dp0 dp1 val bod -> let val' = coreToString val in let bod' = coreToString bod in "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ val' ++ "\n" ++ bod' Ref nam fid arg -> let arg' = intercalate " " (map coreToString arg) in "@" ++ nam ++ "(" ++ arg' ++ ")" Ctr cid fds -> let fds' = unwords (map coreToString fds) in "#" ++ show cid ++ "{" ++ fds' ++ "}" Mat val mov css -> let val' = coreToString val in let mov' = concatMap (\ (k,v) -> " !" ++ k ++ "=" ++ coreToString v) mov in let css' = unwords [ctr ++ "{" ++ unwords fds ++ "}:" ++ coreToString bod | (ctr, fds, bod) <- css] in "(~" ++ val' ++ mov' ++ " {" ++ css' ++ "})" U32 val -> show val Op2 opr nm0 nm1 -> let nm0' = coreToString nm0 in let nm1' = coreToString nm1 in "(" ++ operToString opr ++ " " ++ nm0' ++ " " ++ nm1' ++ ")" Let mod nam val bod -> let val' = coreToString val in let bod' = coreToString bod in "! " ++ modeToString mod ++ nam ++ " = " ++ val' ++ " " ++ bod' #44: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #45: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #46: -- Runtime Stringification -- ----------------------- #47: tagToString :: Tag -> String tagToString t = show (tagT t) #48: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #49: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #50: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #51: -- Dumping -- ------- #52: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #53: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #54: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #55: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #56: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #57: -- //./Type.hs// #58: module HVML.Parse where #59: import Control.Monad (foldM, forM) import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #60: -- Core Parsers -- ------------ #61: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #62: type ParserM = Parsec String ParserState #63: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #64: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #65: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #66: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore -- Parse mov (external variables) mov <- many $ do try $ do skip consume "!" key <- parseName val <- optionMaybe $ do try $ consume "=" parseCore case val of Just v -> return (key, v) Nothing -> return (key, Var key) consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar -- Parse constructor case if next == '#' then do consume "#" ctr <- parseName fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName consume "}" return fds consume ":" bod <- parseCore return (ctr, fds, bod) -- Parse numeric case else do num <- parseName case reads num of [(n :: Word64, "")] -> do consume ":" bod <- parseCore return (num, [], bod) otherwise -> do consume ":" bod <- parseCore return ("+", [num], bod) consume "}" css <- forM css $ \(ctr, fds, bod) -> do cid <- case reads ctr of [(num, "")] -> return $ Left (read num :: Word64) _ -> do st <- getState; return $ Right $ fromMaybe maxBound $ MS.lookup ctr (parsedCtrToCid st) return (cid, (ctr, fds, bod)) css <- return $ map snd $ sortOn fst css return $ Mat val mov css #67: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #68: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #69: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #70: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #71: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #72: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #73: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #74: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> do return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #75: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #76: -- Helper Parsers -- -------------- #77: consume :: String -> ParserM String consume str = spaces >> string str #78: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #79: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #80: -- Adjusting -- --------- #81: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #82: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x mov css -> Mat (setRefIds fids x) (map (\ (k,v) -> (k, setRefIds fids v)) mov) (map (\ (ctr,fds,cs) -> (ctr, fds, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #83: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #84: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #85: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val mov css -> do val' <- go val ctx mov' <- forM mov $ \ (k,v) -> do k' <- fresh k v <- go v ctx return $ (k', v) css' <- forM css $ \ (ctr,fds,bod) -> do fds' <- mapM fresh fds ctx <- foldM (\ ctx (fd,fd') -> extend fd fd' ctx) ctx (zip fds fds') ctx <- foldM (\ ctx ((k,_),(k',_)) -> extend k k' ctx) ctx (zip mov mov') bod <- go bod ctx return (ctr, fds', bod) return $ Mat val' mov' css' Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #86: -- Errors -- ------ #87: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #88: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #89: -- //./Type.hs// #90: module HVML.Reduce where #91: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #92: reduceAt :: Bool -> ReduceAt reduceAt debug book host = do term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt (const got) book 0 core <- doExtractCoreAt (const got) book host putStrLn $ "reduce: " ++ termToString term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt debug book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt debug book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt debug book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt debug book host MAT -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt debug book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt debug book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt debug book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt debug book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt debug book host #93: reduceCAt :: Bool -> ReduceAt reduceCAt = \ _ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #94: -- normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term -- normalAtWith reduceAt book host = do -- term <- got host -- if termBit term == 1 then do -- return term -- else do -- whnf <- reduceAt book host -- set host $ termSetBit whnf -- let tag = termTag whnf -- let lab = termLab whnf -- let loc = termLoc whnf -- case tagT tag of -- APP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- LAM -> do -- normalAtWith reduceAt book (loc + 1) -- return whnf -- SUP -> do -- normalAtWith reduceAt book (loc + 0) -- normalAtWith reduceAt book (loc + 1) -- return whnf -- DP0 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- DP1 -> do -- normalAtWith reduceAt book (loc + 0) -- return whnf -- CTR -> do -- let ari = u12v2Y lab -- let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- MAT -> do -- let ari = lab -- let ars = [0 .. ari] :: [Word64] -- mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars -- return whnf -- _ -> do -- return whnf #95: -- normalAt :: Book -> Loc -> HVM Term -- normalAt = normalAtWith (reduceAt False) #96: -- normalCAt :: Book -> Loc -> HVM Term -- normalCAt = normalAtWith (reduceCAt False) ./Compile.hs #97: -- //./Type.hs// -- //./Inject.hs// #98: module HVML.Compile where #99: import Control.Monad (forM_, forM, foldM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #100: import Debug.Trace #101: -- Compilation -- ----------- #102: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #103: type Compile = State CompileState #104: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #105: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #106: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #107: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #108: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #109: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #110: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #111: -- Full Compiler -- ------------- #112: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #113: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #114: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val mov css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do -- Create a chain of lambdas for fields and moved vars let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFullCore book fid bod' (matNam ++ " + " ++ show (i+1)) emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFullCore book fid val (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #115: -- Fast Compiler -- ------------- #116: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #117: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #118: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val mov css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && (let (ctr,fds,bod) = css !! 0 in ctr == "0") -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length mov) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" forM_ fds $ \ fd -> do bind fd preNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ctr,fds,bod)) -> do emit $ "case " ++ show i ++ ": {" tabInc forM_ (zip [0..] fds) $ \ (k,fd) -> do fdNam <- fresh "fd" emit $ "Term " ++ fdNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" bind fd fdNam forM_ mov $ \ (key,val) -> do valT <- compileFastCore book fid val bind key valT compileFastBody book fid bod ctx (itr + 1 + length fds + length mov) -- compileFastApps book fid bod args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #119: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #120: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #121: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val mov css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" forM_ (zip [0..] css) $ \ (i,(ctr,fds,bod)) -> do let bod' = foldr Lam (foldr Lam bod (map fst mov)) fds bodT <- compileFastCore book fid bod' emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ bodT ++ ");" -- Create the base Mat term let mat = "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" -- Apply moved values foldM (\term (key, val) -> do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" valT <- compileFastCore book fid val emit $ "set(" ++ appNam ++ " + 0, " ++ term ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ valT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" ) mat mov #122: compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #123: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #124: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #125: -- Type.hs: -- //./Type.hs// #126: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #127: module Main where #128: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #129: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #130: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #131: -- Main -- ---- #132: data RunMode = Normalize | Collapse | Search deriving Eq #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let debug = "-d" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file debug compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" putStrLn " -d # Print execution steps (debug mode)" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath debug compiled mode showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return (reduceCAt debug) else return (reduceAt debug) vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(String,Core)] [(String,[String],Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #178: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #179: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #180: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #182: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #209: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #210: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #211: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #212: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #214: -- Constants -- --------- #215: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #216: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #217: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #218: //./Type.hs// #219: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #220: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #221: typedef _Atomic(Term) ATerm; #222: // Runtime Types // ------------- #223: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #224: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #225: // Constants // --------- #226: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #227: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #228: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #229: #define VOID 0x00000000000000 #230: // Heap // ---- #231: Loc get_len() { return *HVM.size; } #232: u64 get_itr() { return *HVM.itrs; } #233: void set_len(Loc value) { *HVM.size = value; } #234: void set_itr(Loc value) { *HVM.itrs = value; } #235: // Terms // ------ #236: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #237: Tag term_tag(Term x) { return x & 0x7F; } #238: Tag term_bit(Term x) { return (x >> 7) & 1; } #239: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #240: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #241: Term term_set_bit(Term term) { return term | (1ULL << 7); } #242: // u12v2 // ----- #243: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #244: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #245: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #246: // Atomics // ------- #247: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #248: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #249: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term take(Loc loc) { return swap(loc, VOID); } #251: // Allocation // ---------- #252: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #253: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #254: // Stringification // --------------- #255: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #256: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #257: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #258: // Evaluation // ---------- #259: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #260: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #261: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #262: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #263: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #264: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #265: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #266: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #267: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #268: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #269: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #271: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #272: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #273: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); //Loc mat0 = mat_loc; Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #274: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #275: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #276: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #277: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #278: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #279: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #280: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #281: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #282: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #283: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #284: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #285: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #286: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #287: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #288: // Runtime Memory // -------------- #289: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #290: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #291: State* hvm_get_state() { return &HVM; } #292: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #293: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #294: -- //./Type.hs// #295: module HVML.Extract where #296: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #297: import Debug.Trace #298: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #299: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #300: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #301: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #302: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #303: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #304: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do print "AAA" let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return ("#", [], c)) css -- FIXME: recover names and fields on extraction (must store id) return $ Mat val [] css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab let aux = if ari == 0 then [] else [0..ari-1] arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) aux let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #305: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #306: -- Lifting Dups -- ------------ #307: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val mov css) = do val <- liftDups val mov <- mapM (\(key, val) -> do val <- liftDups val return (key, val)) mov css <- mapM (\(ctr, fds, bod) -> do bod <- liftDups bod return (ctr, fds, bod)) css return $ Mat val mov css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #308: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #309: module HVML.Inject where #310: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #311: type InjectM a = StateT InjectState HVM a #312: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #313: emptyState :: InjectState emptyState = InjectState Map.empty [] #314: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #315: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #316: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #317: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #318: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #319: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #320: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #321: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #322: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #323: injectCore book (Mat val mov css) loc = do -- Allocate space for the Mat term mat <- lift $ allocNode (1 + fromIntegral (length css)) -- Inject the value being matched injectCore book val (mat + 0) -- Process each case forM_ (zip [0..] css) $ \ (idx, (ctr, fds, bod)) -> do -- Inject the case body into memory injectCore book (foldr Lam (foldr Lam bod (map fst mov)) fds) (mat + 1 + idx) -- After processing all cases, create the Mat term trm <- return $ termNew _MAT_ (fromIntegral (length css)) mat ret <- foldM (\mat (_, val) -> do app <- lift $ allocNode 2 lift $ set (app + 0) mat injectCore book val (app + 1) return $ termNew _APP_ 0 app) trm mov lift $ set loc ret #324: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #325: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #326: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

87f797b649cbd4233c433da9783cfbf321bae6f2

2-port dup nodes; reuse memory; enforce affinity dup nodes are now stored in two ports. before reduction, we use the first port to represent the value, and the second is just SUB. after reduction, both ports become the substitutions. we'll now reuse memory of some nodes, instead of allocating. these changes increase performance by ~50% in some cases I've also noticed that, sadly, we can't actually use variables non-linearly on branches, as in: λb ~x{ #T: ... b ... #F: ... b ... } that's because, in certain superposed situations, we can actually reach both branches, causing the 'b' pointer to appear in two places in memory, which should never happen. as such, we need to linearize, as we did before: λb (~x{ #T: λb ... b ... #F: λb ... b ... } b) because of that, HVM3 will now throw an error if a variable is used non-linearly, even if across different branches. I'll update the syntax to make this limitation more palatable also, note that, now, the fast-compiled mode will sometimes perform more interactions than the interpreted mode. that's because some optimizations (like applying the λ's of a mat interaction) lose some laziness (perhaps these λ's wouldn't be applied in a very superposed situation). that's fine and I'll keep it like that. we could add a "compiled but without optimizations" option later if we want a consistent interaction count.

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 0) return whnf DP1 -> do normalAtWith reduceAt book (loc + 0) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: data RunMode = Normalize | Collapse | Search deriving Eq #134: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #135: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" return $ Right () #136: -- CLI Commands -- ------------ #137: cliRun :: FilePath -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath compiled mode showStats = do -- Initialize the HVM hvmInit #138: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #139: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #140: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #141: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #142: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #143: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #144: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #145: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #146: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #147: -- Prints total time end <- getCPUTime #148: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #149: -- Finalize hvmFree return $ Right () #150: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #151: -- //./Runtime.c// #152: module HVML.Type where #153: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #154: -- Core Types -- ---------- #155: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #156: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #157: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #158: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #159: type Func = ([String], Core) #160: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #161: -- Runtime Types -- ------------- #162: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #163: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #164: type HVM = IO #165: type ReduceAt = Book -> Loc -> HVM Term #166: -- C Functions -- ----------- #167: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #168: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #169: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #170: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #171: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #173: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #174: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #175: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #176: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #177: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #178: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #179: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #180: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #181: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #183: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #211: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #212: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #213: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #215: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #216: -- Constants -- --------- #217: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #218: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #219: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #220: //./Type.hs// #221: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #222: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #223: typedef _Atomic(Term) ATerm; #224: // Runtime Types // ------------- #225: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #226: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #227: // Constants // --------- #228: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #229: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #230: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #231: #define VOID 0x00000000000000 #232: // Heap // ---- #233: Loc get_len() { return *HVM.size; } #234: u64 get_itr() { return *HVM.itrs; } #235: void set_len(Loc value) { *HVM.size = value; } #236: void set_itr(Loc value) { *HVM.itrs = value; } #237: // Terms // ------ #238: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #239: Tag term_tag(Term x) { return x & 0x7F; } #240: Tag term_bit(Term x) { return (x >> 7) & 1; } #241: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #242: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); //Loc mat0 = alloc_node(1 + mat_len); Loc mat0 = mat_loc; Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let loc = termLoc term sub <- got loc if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef loc return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #21: DP1 -> do let loc = termLoc term let lab = termLab term sb0 <- got (loc+0) sb1 <- got (loc+1) if termTag sb1 /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 0) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb0 reduceAt book host DP1 -> do sb0 <- got (loc + 0) sb1 <- got (loc + 1) if termTag sb1 == _SUB_ then do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 0) val >> return term else do set host sb1 reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 0) return whnf DP1 -> do normalAtWith reduceAt book (loc + 0) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 0") emit $ "set(" ++ dupNam ++ " + 0, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(2);" emit $ "set(" ++ dupNam ++ " + 0, " ++ valNam ++ ");" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: data RunMode = Normalize | Collapse | Search deriving Eq #134: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #135: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" return $ Right () #136: -- CLI Commands -- ------------ #137: cliRun :: FilePath -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath compiled mode showStats = do -- Initialize the HVM hvmInit #138: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #139: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #140: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #141: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #142: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #143: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #144: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #145: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #146: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #147: -- Prints total time end <- getCPUTime #148: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #149: -- Finalize hvmFree return $ Right () #150: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #151: -- //./Runtime.c// #152: module HVML.Type where #153: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #154: -- Core Types -- ---------- #155: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #156: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #157: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #158: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #159: type Func = ([String], Core) #160: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #161: -- Runtime Types -- ------------- #162: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #163: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #164: type HVM = IO #165: type ReduceAt = Book -> Loc -> HVM Term #166: -- C Functions -- ----------- #167: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #168: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #169: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #170: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #171: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #173: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #174: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #175: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #176: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #177: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #178: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #179: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #180: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #181: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #183: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #211: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #212: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #213: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #215: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #216: -- Constants -- --------- #217: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #218: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #219: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #220: //./Type.hs// #221: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #222: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #223: typedef _Atomic(Term) ATerm; #224: // Runtime Types // ------------- #225: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Loc* free2_ini; // freelist Loc* free2_end; // freelist Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #226: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #227: // Constants // --------- #228: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #229: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #230: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #231: #define VOID 0x00000000000000 #232: // Heap // ---- #233: Loc get_len() { return *HVM.size; } #234: u64 get_itr() { return *HVM.itrs; } #235: void set_len(Loc value) { *HVM.size = value; } #236: void set_itr(Loc value) { *HVM.itrs = value; } #237: // Terms // ------ #238: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #239: Tag term_tag(Term x) { return x & 0x7F; } #240: Tag term_bit(Term x) { return (x >> 7) & 1; } #241: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #242: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { Term val = atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); if (val == 0) { printf("SWAP 0 at %x\n", loc); exit(0); } return val; } #250: Term got(Loc loc) { Term val = atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); if (val == 0) { printf("GOT 0 at %x\n", loc); exit(0); } return val; } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("reduce_ref "); print_term(ref); printf("\n"); //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { //printf("reduce_let "); print_term(let); printf("\n"); inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { //printf("reduce_app_era "); print_term(app); printf("\n"); inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { //printf("reduce_app_lam "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { //printf("reduce_app_sup "); print_term(app); printf("\n"); inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc su0 = alloc_node(2); //Loc ap0 = alloc_node(2); Loc ap0 = app_loc; Loc su0 = sup_loc; Loc ap1 = alloc_node(2); set(du0 + 0, arg); set(du0 + 1, term_new(SUB, 0, 0)); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { //printf("reduce_app_ctr "); print_term(app); printf("\n"); printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { //printf("reduce_app_w32 "); print_term(app); printf("\n"); printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { //printf("reduce_dup_era "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { //printf("reduce_dup_lam "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(2); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, bod); set(du0 + 1, term_new(SUB, 0, 0)); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { //printf("reduce_dup_sup %u %u | %llu ", term_lab(dup), term_lab(sup), *HVM.spos); print_term(dup); printf(" "); print_term(sup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(2); Loc du1 = alloc_node(2); //Loc su0 = alloc_node(2); Loc su0 = sup_loc; Loc su1 = alloc_node(2); Term tm0 = take(sup_loc + 0); Term tm1 = take(sup_loc + 1); set(du0 + 0, tm0); set(du0 + 1, term_new(SUB, 0, 0)); set(du1 + 0, tm1); set(du1 + 1, term_new(SUB, 0, 0)); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { //printf("reduce_dup_ctr "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); //Loc ctr0 = alloc_node(ctr_ari); Loc ctr0 = ctr_loc; Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(ctr_loc + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { //printf("reduce_dup_w32 "); print_term(dup); printf("\n"); inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { //printf("reduce_mat_era "); print_term(mat); printf("\n"); inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { //printf("reduce_mat_lam "); print_term(mat); printf("\n"); printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { //printf("reduce_mat_sup "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); //Loc mat0 = mat_loc; Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, got(mat_loc + 1 + i)); set(du0 + 1, term_new(SUB, 0, 0)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { //printf("reduce_mat_ctr "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { //printf("reduce_mat_w32 "); print_term(mat); printf("\n"); inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { //printf("reduce_opx_era "); print_term(opx); printf("\n"); inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { //printf("reduce_opx_lam "); print_term(opx); printf("\n"); printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { //printf("reduce_opx_sup "); print_term(opx); printf("\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(2); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opx_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(du0 + 0, nmy); set(du0 + 1, term_new(SUB, 0, 0)); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { //printf("reduce_opx_ctr "); print_term(opx); printf("\n"); printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { //printf("reduce_opx_w32 "); print_term(opx); printf("\n"); inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { //printf("reduce_opy_era "); print_term(opy); printf("\n"); inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { //printf("reduce_opy_lam "); print_term(opy); printf("\n"); printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { //printf("reduce_opy_sup "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); //Loc op0 = alloc_node(2); //Loc op1 = alloc_node(2); Loc op0 = opy_loc; Loc op1 = sup_loc; Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { //printf("reduce_opy_ctr "); print_term(opy); printf("\n"); printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { //printf("reduce_opy_w32 "); print_term(opy); printf("\n"); inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT "); print_term(term); printf("\n"); //printf("PATH "); //for (u64 i = 0; i < *spos; ++i) { //print_tag(term_tag(HVM.sbuf[i])); //printf(" "); //} //printf(" ~ %p", HVM.sbuf); //printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb0; continue; } } case DP1: { Term sb0 = got(loc + 0); Term sb1 = got(loc + 1); if (term_tag(sb1) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } else { next = sb1; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Term sub = got(loc); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 0, next); break; case DP1: set(hloc + 0, next); break; case MAT: set(hloc + 0, next); break; } *HVM.spos = stop; return HVM.sbuf[stop]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 0); val = normal(val); set(loc + 0, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let loc = termLoc term name <- genName state loc return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 0) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (loc + 1) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book loc modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do argsMap <- gets args case Map.lookup nam argsMap of Just term -> do lift $ set loc term modify $ \s -> s { args = Map.delete nam (args s) } Nothing -> do modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 2 -- lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 0) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) foldM (\m (name, loc) -> do print $ "GOT " ++ name case Map.lookup name (args state) of Just term -> do set loc term return $ Map.delete name m Nothing -> do error $ "Unbound variable: " ++ name) (args state) (vars state) got host

ceb449698df735890a1d29632aafe016aea6803e

search mode: collapse, then print first result

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print all collapsed results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints just the first collapsed result -- putStrLn $ coreToString (head vals) #146: -- Prints total time end <- getCPUTime #147: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #148: -- Finalize hvmFree return $ Right () #149: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #150: -- //./Runtime.c// #151: module HVML.Type where #152: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #153: -- Core Types -- ---------- #154: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #155: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #156: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #157: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #158: type Func = ([String], Core) #159: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #160: -- Runtime Types -- ------------- #161: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #162: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #163: type HVM = IO #164: type ReduceAt = Book -> Loc -> HVM Term #165: -- C Functions -- ----------- #166: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #167: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #168: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #169: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #170: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #173: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #174: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #176: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #177: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #179: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #180: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #181: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #183: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #211: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #212: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #213: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #215: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #216: -- Constants -- --------- #217: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #218: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #219: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #220: //./Type.hs// #221: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #222: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #223: typedef _Atomic(Term) ATerm; #224: // Runtime Types // ------------- #225: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #226: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #227: // Constants // --------- #228: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #229: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #230: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #231: #define VOID 0x00000000000000 #232: // Heap // ---- #233: Loc get_len() { return *HVM.size; } #234: u64 get_itr() { return *HVM.itrs; } #235: void set_len(Loc value) { *HVM.size = value; } #236: void set_itr(Loc value) { *HVM.itrs = value; } #237: // Terms // ------ #238: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #239: Tag term_tag(Term x) { return x & 0x7F; } #240: Tag term_bit(Term x) { return (x >> 7) & 1; } #241: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #242: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #243: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #244: Term term_set_bit(Term term) { return term | (1ULL << 7); } #245: // u12v2 // ----- #246: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #247: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #248: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #249: // Atomics // ------- #250: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #251: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #252: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #253: Term take(Loc loc) { return swap(loc, VOID); } #254: // Allocation // ---------- #255: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #256: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #257: // Stringification // --------------- #258: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #259: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #260: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #261: // Evaluation // ---------- #262: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #263: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #264: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #265: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #266: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #267: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #268: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #269: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #270: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #271: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #272: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #273: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #274: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #275: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #276: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #277: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #278: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #279: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #280: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #281: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #282: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #283: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #284: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #285: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #286: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #287: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #288: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #289: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #290: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #291: // Runtime Memory // -------------- #292: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #293: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #294: State* hvm_get_state() { return &HVM; } #295: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #296: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #297: -- //./Type.hs// #298: module HVML.Extract where #299: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #300: import Debug.Trace #301: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #302: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #303: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #304: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #305: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #306: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #307: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #308: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #309: -- Lifting Dups -- ------------ #310: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #311: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #312: module HVML.Inject where #313: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #314: type InjectM a = StateT InjectState HVM a #315: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #316: emptyState :: InjectState emptyState = InjectState Map.empty [] #317: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #318: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #319: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #320: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #321: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #322: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #323: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #324: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #325: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #326: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #327: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #328: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #329: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,b) $ pqPut (k,a) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: data RunMode = Normalize | Collapse | Search deriving Eq #134: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let search = "-S" `elem` args let showStats = "-s" `elem` args let mode = if collapse then Collapse else if search then Search else Normalize cliRun file compiled mode showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #135: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to a list of λ-Terms" putStrLn " -S # Search (collapse, then print the 1st λ-Term)" putStrLn " -s # Show statistics" return $ Right () #136: -- CLI Commands -- ------------ #137: cliRun :: FilePath -> Bool -> RunMode -> Bool -> IO (Either String ()) cliRun filePath compiled mode showStats = do -- Initialize the HVM hvmInit #138: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #139: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #140: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #141: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #142: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #143: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #144: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if mode == Collapse || mode == Search then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #145: -- Print all collapsed results when (mode == Collapse) $ do forM_ vals $ \ term -> putStrLn $ coreToString term #146: -- Prints just the first collapsed result when (mode == Search || mode == Normalize) $ do putStrLn $ coreToString (head vals) #147: -- Prints total time end <- getCPUTime #148: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.7f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #149: -- Finalize hvmFree return $ Right () #150: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #151: -- //./Runtime.c// #152: module HVML.Type where #153: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #154: -- Core Types -- ---------- #155: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #156: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #157: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #158: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #159: type Func = ([String], Core) #160: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #161: -- Runtime Types -- ------------- #162: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #163: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #164: type HVM = IO #165: type ReduceAt = Book -> Loc -> HVM Term #166: -- C Functions -- ----------- #167: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #168: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #169: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #170: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #171: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #173: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #174: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #175: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #176: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #177: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #178: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #179: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #180: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #181: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #182: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #183: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #184: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #210: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #211: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #212: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #213: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #214: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #215: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #216: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #217: -- Constants -- --------- #218: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #219: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #220: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #221: //./Type.hs// #222: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #223: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #224: typedef _Atomic(Term) ATerm; #225: // Runtime Types // ------------- #226: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #227: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #228: // Constants // --------- #229: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #230: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #231: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #232: #define VOID 0x00000000000000 #233: // Heap // ---- #234: Loc get_len() { return *HVM.size; } #235: u64 get_itr() { return *HVM.itrs; } #236: void set_len(Loc value) { *HVM.size = value; } #237: void set_itr(Loc value) { *HVM.itrs = value; } #238: // Terms // ------ #239: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #240: Tag term_tag(Term x) { return x & 0x7F; } #241: Tag term_bit(Term x) { return (x >> 7) & 1; } #242: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #243: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #244: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #245: Term term_set_bit(Term term) { return term | (1ULL << 7); } #246: // u12v2 // ----- #247: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #248: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #249: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #250: // Atomics // ------- #251: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #253: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #254: Term take(Loc loc) { return swap(loc, VOID); } #255: // Allocation // ---------- #256: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #257: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #258: // Stringification // --------------- #259: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #260: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #261: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #262: // Evaluation // ---------- #263: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #264: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #265: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #266: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #267: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #268: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #269: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #270: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #271: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #273: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #274: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #275: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #276: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #277: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #278: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #279: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #280: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #281: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #282: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #283: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #284: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #285: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #286: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #287: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #288: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #289: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #290: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #291: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #292: // Runtime Memory // -------------- #293: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #294: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #295: State* hvm_get_state() { return &HVM; } #296: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #297: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #298: -- //./Type.hs// #299: module HVML.Extract where #300: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #301: import Debug.Trace #302: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #303: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #304: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #305: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #306: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #307: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #308: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #309: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #310: -- Lifting Dups -- ------------ #311: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #312: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #313: module HVML.Inject where #314: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #315: type InjectM a = StateT InjectState HVM a #316: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #317: emptyState :: InjectState emptyState = InjectState Map.empty [] #318: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #319: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #320: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #321: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #322: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #323: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #324: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #325: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #326: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #327: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #328: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #329: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #330: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

b559f6b1046c64f5cefac816bf868204a7e8d686

fix nullary ctr collapser

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints total time end <- getCPUTime #146: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #147: -- Finalize hvmFree return $ Right () #148: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #149: -- //./Runtime.c// #150: module HVML.Type where #151: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #152: -- Core Types -- ---------- #153: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #179: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #180: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #210: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #211: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #212: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #215: -- Constants -- --------- #216: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #217: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #218: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #219: //./Type.hs// #220: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #221: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #222: typedef _Atomic(Term) ATerm; #223: // Runtime Types // ------------- #224: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #225: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #226: // Constants // --------- #227: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #228: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #229: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #230: #define VOID 0x00000000000000 #231: // Heap // ---- #232: Loc get_len() { return *HVM.size; } #233: u64 get_itr() { return *HVM.itrs; } #234: void set_len(Loc value) { *HVM.size = value; } #235: void set_itr(Loc value) { *HVM.itrs = value; } #236: // Terms // ------ #237: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #238: Tag term_tag(Term x) { return x & 0x7F; } #239: Tag term_bit(Term x) { return (x >> 7) & 1; } #240: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #241: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #242: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [loc + i | i <- [0..ari-1]] fds0 <- mapM (collapseDupsAt state reduceAt book) ars return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints total time end <- getCPUTime #146: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #147: -- Finalize hvmFree return $ Right () #148: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #149: -- //./Runtime.c// #150: module HVML.Type where #151: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #152: -- Core Types -- ---------- #153: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #179: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #180: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #210: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #211: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #212: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #215: -- Constants -- --------- #216: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #217: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #218: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #219: //./Type.hs// #220: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #221: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #222: typedef _Atomic(Term) ATerm; #223: // Runtime Types // ------------- #224: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #225: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #226: // Constants // --------- #227: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #228: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #229: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #230: #define VOID 0x00000000000000 #231: // Heap // ---- #232: Loc get_len() { return *HVM.size; } #233: u64 get_itr() { return *HVM.itrs; } #234: void set_len(Loc value) { *HVM.size = value; } #235: void set_itr(Loc value) { *HVM.itrs = value; } #236: // Terms // ------ #237: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #238: Tag term_tag(Term x) { return x & 0x7F; } #239: Tag term_bit(Term x) { return (x >> 7) & 1; } #240: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #241: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #242: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

441c94be0568df08a78561f398cbebda3a07a9c2

collapsed erasures destroy an universe For example, the term below: @main = λt(t &0{* 2} &0{3 4}) Will collapse as just: λa ((a 2) 4) The '3' doesn't appear, because '*' occurs at the [0] path of the 0'th label, which acts like ⊥, destroying this "parallel universe".

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Era -> return Era Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints total time end <- getCPUTime #146: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #147: -- Finalize hvmFree return $ Right () #148: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #149: -- //./Runtime.c// #150: module HVML.Type where #151: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #152: -- Core Types -- ---------- #153: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #179: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #180: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #210: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #211: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #212: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #215: -- Constants -- --------- #216: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #217: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #218: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #219: //./Type.hs// #220: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #221: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #222: typedef _Atomic(Term) ATerm; #223: // Runtime Types // ------------- #224: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #225: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #226: // Constants // --------- #227: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #228: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #229: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #230: #define VOID 0x00000000000000 #231: // Heap // ---- #232: Loc get_len() { return *HVM.size; } #233: u64 get_itr() { return *HVM.itrs; } #234: void set_len(Loc value) { *HVM.size = value; } #235: void set_itr(Loc value) { *HVM.itrs = value; } #236: // Terms // ------ #237: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #238: Tag term_tag(Term x) { return x & 0x7F; } #239: Tag term_bit(Term x) { return (x >> 7) & 1; } #240: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #241: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #242: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body Era -> do CEra Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints total time end <- getCPUTime #146: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #147: -- Finalize hvmFree return $ Right () #148: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #149: -- //./Runtime.c// #150: module HVML.Type where #151: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #152: -- Core Types -- ---------- #153: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #179: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #180: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #210: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #211: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #212: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #215: -- Constants -- --------- #216: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #217: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #218: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #219: //./Type.hs// #220: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #221: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #222: typedef _Atomic(Term) ATerm; #223: // Runtime Types // ------------- #224: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #225: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #226: // Constants // --------- #227: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #228: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #229: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #230: #define VOID 0x00000000000000 #231: // Heap // ---- #232: Loc get_len() { return *HVM.size; } #233: u64 get_itr() { return *HVM.itrs; } #234: void set_len(Loc value) { *HVM.size = value; } #235: void set_itr(Loc value) { *HVM.itrs = value; } #236: // Terms // ------ #237: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #238: Tag term_tag(Term x) { return x & 0x7F; } #239: Tag term_bit(Term x) { return (x >> 7) & 1; } #240: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #241: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #242: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

6da8b428d7d00d82d50465028bd19ef43c1a4eea

HVM lazy evaluation propagates to Haskell side Now, instead of expecting a normalized term, the extract/collapse functions will call reduce layer by layer, with unsafeInterleaveIO. As a result, laziness will propagate from Haskell to HVM, in the sense that we will only compute interactions that are observable on Haskell side. So, for example, if part of the term is discarded, the count will also decrease, as the irrelevant interactions won't be mde. Also, the Collapser will now use a priority queue, so that the list of λ-Terms collapsed is visited from lowest to highest labels. This has proven to be relevant for proof search. Other strategies may be considered later, though. I've also added the missing Collapse.hs file.

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #45: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #46: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #47: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #48: -- Errors -- ------ #49: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #50: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #51: -- //./Type.hs// #52: module HVML.Reduce where #53: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #54: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #55: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #56: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #57: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #58: -- //./Type.hs// -- //./Inject.hs// #59: module HVML.Compile where #60: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #61: import Debug.Trace #62: -- Compilation -- ----------- #63: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #64: type Compile = State CompileState #65: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #66: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #67: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #68: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #69: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #70: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #71: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #72: -- Full Compiler -- ------------- #73: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #74: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #75: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #76: -- Fast Compiler -- ------------- #77: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #78: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #79: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #80: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #81: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #82: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #83: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #84: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #85: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #86: -- Type.hs: -- //./Type.hs// #87: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #88: module Main where #89: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #90: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #91: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #92: -- Main -- ---- #93: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #94: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-c] [-C] [-s] <file> # Normalizes the specified file" putStrLn " -c # Compile to native code" putStrLn " -C # Collapse the result" putStrLn " -s # Show statistics" putStrLn " hvml help # Shows this help message" return $ Right () #95: -- CLI Commands -- ------------ #96: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #97: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #98: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #99: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #100: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #101: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #102: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #103: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- if compiled then normalCAt book 0 else normalAt book 0 vals <- if collapse then do doCollapseCore book norm else do core <- doExtractCore book norm return [core] end <- getCPUTime #104: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #105: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #106: -- Finalize hvmFree return $ Right () #107: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #108: -- //./Runtime.c// #109: module HVML.Type where #110: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #111: -- Core Types -- ---------- #112: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #113: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #114: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #115: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #116: type Func = ([String], Core) #117: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #118: -- Runtime Types -- ------------- #119: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #120: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #121: type HVM = IO #122: -- C Functions -- ----------- #123: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #124: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #125: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #126: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #127: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #129: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #130: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #131: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #132: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #133: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #134: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #135: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #136: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #137: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #138: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #139: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #140: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #168: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #169: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #170: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #171: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #172: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #173: -- Constants -- --------- #174: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #175: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #176: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #177: //./Type.hs// #178: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #179: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #180: typedef _Atomic(Term) ATerm; #181: // Runtime Types // ------------- #182: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #183: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #184: // Constants // --------- #185: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #186: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #187: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #188: #define VOID 0x00000000000000 #189: // Heap // ---- #190: Loc get_len() { return *HVM.size; } #191: u64 get_itr() { return *HVM.itrs; } #192: void set_len(Loc value) { *HVM.size = value; } #193: void set_itr(Loc value) { *HVM.itrs = value; } #194: // Terms // ------ #195: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #196: Tag term_tag(Term x) { return x & 0x7F; } #197: Tag term_bit(Term x) { return (x >> 7) & 1; } #198: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #199: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #200: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #201: Term term_set_bit(Term term) { return term | (1ULL << 7); } #202: // u12v2 // ----- #203: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #204: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #205: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #206: // Atomics // ------- #207: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #208: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #209: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #210: Term take(Loc loc) { return swap(loc, VOID); } #211: // Allocation // ---------- #212: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #213: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #214: // Stringification // --------------- #215: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #216: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #217: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #218: // Evaluation // ---------- #219: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #220: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #221: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #222: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #223: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #224: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #225: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #226: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #227: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #228: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #229: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #230: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #231: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #232: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #233: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #234: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #235: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #236: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #237: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #238: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #239: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #240: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #241: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #242: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #243: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #244: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #245: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #246: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #247: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #248: // Runtime Memory // -------------- #249: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #250: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #251: State* hvm_get_state() { return &HVM; } #252: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #253: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #254: -- //./Type.hs// #255: module HVML.Extract where #256: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #257: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #258: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #259: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #260: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #261: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #262: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #263: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #264: -- Lifting Dups -- ------------ #265: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #266: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #267: module HVML.Inject where #268: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #269: type InjectM a = StateT InjectState HVM a #270: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #271: emptyState :: InjectState emptyState = InjectState Map.empty [] #272: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #273: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #274: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #275: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #276: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #277: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #278: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #279: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #280: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #281: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #282: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #283: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #284: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Collapse.hs #1: -- //./Type.hs// #2: module HVML.Collapse where #3: import Control.Monad (ap, forM_) import Control.Monad.IO.Class import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Type import HVML.Show import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #4: -- The Collapse Monad -- ------------------ -- See: https://gist.github.com/VictorTaelin/60d3bc72fb4edefecd42095e44138b41 #5: -- A bit-string data Bin = O Bin | I Bin | E deriving Show #6: -- A Collapse is a tree of superposed values data Collapse a = CSup Word64 (Collapse a) (Collapse a) | CVal a | CEra deriving Show #7: -- The Collapse Monad bind :: Collapse a -> (a -> Collapse b) -> Collapse b bind a f = fork a (repeat (\x -> x)) where fork CEra paths = CEra fork (CVal v) paths = pass (f v) (map (\x -> x E) paths) fork (CSup k x y) paths = CSup k (fork x (mut k putO paths)) (fork y (mut k putI paths)) pass CEra paths = CEra pass (CVal v) paths = CVal v pass (CSup k x y) paths = case paths !! fromIntegral k of E -> CSup k x y O p -> pass x (mut k (\_->p) paths) I p -> pass y (mut k (\_->p) paths) putO bs = \x -> bs (O x) putI bs = \x -> bs (I x) #8: -- Mutates an element at given index in a list mut :: Word64 -> (a -> a) -> [a] -> [a] mut 0 f (x:xs) = f x : xs mut n f (x:xs) = x : mut (n-1) f xs mut _ _ [] = [] #9: instance Functor Collapse where fmap f (CVal v) = CVal (f v) fmap f (CSup k x y) = CSup k (fmap f x) (fmap f y) fmap _ CEra = CEra #10: instance Applicative Collapse where pure = CVal (<*>) = ap #11: instance Monad Collapse where return = pure (>>=) = bind #12: -- Dup Collapser -- ------------- #13: type CollapseDupsState = (IM.IntMap [Int], IORef (MS.Map Loc String)) #14: collapseDupsAt :: CollapseDupsState -> ReduceAt -> Book -> Loc -> HVM Core collapseDupsAt state@(paths, namesRef) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> return Era #15: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName namesRef (loc + 0) val0 <- collapseDupsAt state reduceAt book (loc + 1) bod0 <- collapseDupsAt state reduceAt book (loc + 2) return $ Let mode name val0 bod0 #16: LAM -> do let loc = termLoc term name <- genName namesRef (loc + 0) bod0 <- collapseDupsAt state reduceAt book (loc + 1) return $ Lam name bod0 #17: APP -> do let loc = termLoc term fun0 <- collapseDupsAt state reduceAt book (loc + 0) arg0 <- collapseDupsAt state reduceAt book (loc + 1) return $ App fun0 arg0 #18: SUP -> do let loc = termLoc term let lab = termLab term case IM.lookup (fromIntegral lab) paths of Just (p:ps) -> do let newPaths = IM.insert (fromIntegral lab) ps paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + fromIntegral p) _ -> do tm00 <- collapseDupsAt state reduceAt book (loc + 0) tm11 <- collapseDupsAt state reduceAt book (loc + 1) return $ Sup lab tm00 tm11 #19: VAR -> do let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: VAR does not point to SUB" else do name <- genName namesRef key return $ Var name #20: DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP0 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [0] (0:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #21: DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub /= _SUB_ then do error "Internal Error: DP1 does not point to SUB" else do let newPaths = IM.alter (Just . maybe [1] (1:)) (fromIntegral lab) paths collapseDupsAt (newPaths, namesRef) reduceAt book (loc + 2) #22: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] return $ Ctr cid fds0 #23: MAT -> do let loc = termLoc term let len = termLab term val0 <- collapseDupsAt state reduceAt book (loc + 0) css0 <- mapM (collapseDupsAt state reduceAt book) [loc + 1 + i | i <- [0..len-1]] css1 <- mapM (\ cs -> return (0, cs)) css0 return $ Mat val0 css1 #24: W32 -> do let val = termLoc term return $ U32 (fromIntegral val) #25: OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #26: OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm00 <- collapseDupsAt state reduceAt book (loc + 0) nm10 <- collapseDupsAt state reduceAt book (loc + 1) return $ Op2 opr nm00 nm10 #27: REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg0 <- mapM (collapseDupsAt state reduceAt book) [loc + i | i <- [0..ari-1]] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 #28: genName :: IORef (MS.Map Loc String) -> Loc -> HVM String genName namesRef loc = do nameMap <- readIORef namesRef case MS.lookup loc nameMap of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) modifyIORef' namesRef (MS.insert loc newName) return newName #29: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #30: -- Sup Collapser -- ------------- #31: collapseSups :: Book -> Core -> Collapse Core collapseSups book core = case core of Era -> return Era Var name -> return $ Var name Ref name fid args -> do args <- mapM (collapseSups book) args return $ Ref name fid args Lam name body -> do body <- collapseSups book body return $ Lam name body App fun arg -> do fun <- collapseSups book fun arg <- collapseSups book arg return $ App fun arg Sup lab tm0 tm1 -> do let tm0' = collapseSups book tm0 let tm1' = collapseSups book tm1 CSup lab tm0' tm1' Dup lab x y val body -> do val <- collapseSups book val body <- collapseSups book body return $ Dup lab x y val body Ctr cid fields -> do fields <- mapM (collapseSups book) fields return $ Ctr cid fields Mat val cases -> do val <- collapseSups book val cases <- mapM (\ (arity, expr) -> do expr <- collapseSups book expr return (arity, expr)) cases return $ Mat val cases U32 val -> return $ U32 val Op2 op x y -> do x <- collapseSups book x y <- collapseSups book y return $ Op2 op x y Let mode name val body -> do val <- collapseSups book val body <- collapseSups book body return $ Let mode name val body #32: -- Flattener -- --------- #33: data PQ a = PQLeaf | PQNode (Word64, a) (PQ a) (PQ a) deriving (Show) #34: pqUnion :: PQ a -> PQ a -> PQ a pqUnion PQLeaf heap = heap pqUnion heap PQLeaf = heap pqUnion heap1@(PQNode (k1,v1) l1 r1) heap2@(PQNode (k2,v2) l2 r2) | k1 <= k2 = PQNode (k1,v1) (pqUnion heap2 r1) l1 | otherwise = PQNode (k2,v2) (pqUnion heap1 r2) l2 #35: pqPop :: PQ a -> Maybe ((Word64, a), PQ a) pqPop PQLeaf = Nothing pqPop (PQNode x l r) = Just (x, pqUnion l r) #36: pqPut :: (Word64,a) -> PQ a -> PQ a pqPut (k,v) = pqUnion (PQNode (k,v) PQLeaf PQLeaf) #37: flatten :: Collapse a -> [a] flatten term = go term (PQLeaf :: PQ (Collapse a)) where go (CSup k a b) pq = go CEra (pqPut (k,a) $ pqPut (k,b) $ pq) go (CVal x) pq = x : go CEra pq go CEra pq = case pqPop pq of Just ((k,v),pq) -> go v pq Nothing -> [] #38: -- Core Collapser -- -------------- #39: doCollapseAt :: ReduceAt -> Book -> Loc -> HVM [Core] doCollapseAt reduceAt book host = do namesRef <- newIORef MS.empty let state = (IM.empty, namesRef) core <- collapseDupsAt state reduceAt book host return $ flatten (collapseSups book core) ./Show.hs #40: -- //./Type.hs// -- //./Inject.hs// #41: module HVML.Show where #42: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #43: -- Core Stringification -- -------------------- #44: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #45: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #46: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #47: -- Runtime Stringification -- ----------------------- #48: tagToString :: Tag -> String tagToString t = show (tagT t) #49: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #50: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #51: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #52: -- Dumping -- ------- #53: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #54: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #55: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #56: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #57: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #58: -- //./Type.hs// -- //./Show.hs// #59: module HVML.Parse where #60: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #61: -- Core Parsers -- ------------ #62: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #63: type ParserM = Parsec String ParserState #64: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #65: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #66: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #67: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #68: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #69: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #70: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #71: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #72: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #73: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #74: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #75: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #76: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #77: -- Helper Parsers -- -------------- #78: consume :: String -> ParserM String consume str = spaces >> string str #79: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #80: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #81: -- Adjusting -- --------- #82: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #83: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #84: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #85: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #86: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #87: -- Errors -- ------ #88: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #89: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #90: -- //./Type.hs// #91: module HVML.Reduce where #92: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #93: reduceAt :: ReduceAt reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- doExtractCoreAt reduceAt book 0 core <- doExtractCoreAt reduceAt book host -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #94: reduceCAt :: ReduceAt reduceCAt = \ _ host -> do term <- got host whnf <- reduceC term set host whnf return $ whnf #95: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #96: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #97: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith reduceCAt ./Compile.hs #98: -- //./Type.hs// -- //./Inject.hs// #99: module HVML.Compile where #100: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #101: import Debug.Trace #102: -- Compilation -- ----------- #103: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #104: type Compile = State CompileState #105: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #106: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #107: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #108: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #109: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #110: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #111: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #112: -- Full Compiler -- ------------- #113: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #114: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #115: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #116: -- Fast Compiler -- ------------- #117: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #118: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #119: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #120: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #121: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #122: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #123: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #124: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #125: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #126: -- Type.hs: -- //./Type.hs// #127: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #128: module Main where #129: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #130: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #131: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #132: -- Main -- ---- #133: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #134: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml help # Shows this help message" putStrLn " hvml run <file> [-c] [-C] [-s] # Normalizes the file's main" putStrLn " -c # Runs with compiled mode (fast)" putStrLn " -C # Collapse the result to λ-Terms" putStrLn " -s # Show statistics" return $ Right () #135: -- CLI Commands -- ------------ #136: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #137: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #138: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #139: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #140: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #141: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #142: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #143: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] rxAt <- if compiled then return reduceCAt else return reduceAt vals <- if collapse then doCollapseAt rxAt book 0 else do core <- doExtractCoreAt rxAt book 0 return [(doLiftDups core)] #144: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #145: -- Prints total time end <- getCPUTime #146: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #147: -- Finalize hvmFree return $ Right () #148: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #149: -- //./Runtime.c// #150: module HVML.Type where #151: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #152: -- Core Types -- ---------- #153: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #154: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #155: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #156: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #157: type Func = ([String], Core) #158: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #159: -- Runtime Types -- ------------- #160: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #161: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #162: type HVM = IO #163: type ReduceAt = Book -> Loc -> HVM Term #164: -- C Functions -- ----------- #165: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #166: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #167: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #168: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #169: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #170: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #171: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #172: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #173: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #174: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #175: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #176: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #177: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #178: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #179: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #180: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #181: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #182: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #183: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #184: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #185: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #186: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #187: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #188: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #189: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #190: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #191: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #192: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #193: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #194: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #195: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #196: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #197: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #198: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #199: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #200: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #201: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #202: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #203: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #204: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #205: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #206: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #207: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #208: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #209: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #210: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #211: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #212: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #213: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #214: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #215: -- Constants -- --------- #216: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #217: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #218: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #219: //./Type.hs// #220: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #221: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #222: typedef _Atomic(Term) ATerm; #223: // Runtime Types // ------------- #224: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #225: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #226: // Constants // --------- #227: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #228: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #229: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #230: #define VOID 0x00000000000000 #231: // Heap // ---- #232: Loc get_len() { return *HVM.size; } #233: u64 get_itr() { return *HVM.itrs; } #234: void set_len(Loc value) { *HVM.size = value; } #235: void set_itr(Loc value) { *HVM.itrs = value; } #236: // Terms // ------ #237: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #238: Tag term_tag(Term x) { return x & 0x7F; } #239: Tag term_bit(Term x) { return (x >> 7) & 1; } #240: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #241: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #242: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #243: Term term_set_bit(Term term) { return term | (1ULL << 7); } #244: // u12v2 // ----- #245: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #246: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #247: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #248: // Atomics // ------- #249: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #250: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #251: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #252: Term take(Loc loc) { return swap(loc, VOID); } #253: // Allocation // ---------- #254: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #255: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #256: // Stringification // --------------- #257: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #258: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #259: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #260: // Evaluation // ---------- #261: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #262: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #263: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #264: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #265: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #266: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #267: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #268: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #269: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #270: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #271: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #272: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #273: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #274: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #275: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #276: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #277: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #278: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #279: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #280: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #281: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #282: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #283: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #284: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #285: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #286: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #287: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #288: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #289: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #290: // Runtime Memory // -------------- #291: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #292: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #293: State* hvm_get_state() { return &HVM; } #294: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #295: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #296: -- //./Type.hs// #297: module HVML.Extract where #298: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.IORef import Data.Word import HVML.Show import HVML.Type import System.IO.Unsafe (unsafeInterleaveIO) import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #299: import Debug.Trace #300: type ExtractState = (IORef IS.IntSet, IORef (MS.Map Loc String)) #301: genName :: ExtractState -> Loc -> HVM String genName (_, namsRef) loc = do nams <- readIORef namsRef case MS.lookup loc nams of Just name -> return name Nothing -> do let newName = genNameFromIndex (MS.size nams) modifyIORef' namsRef (MS.insert loc newName) return newName #302: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #303: extractCoreAt :: ExtractState -> ReduceAt -> Book -> Loc -> HVM Core extractCoreAt state@(dupsRef, _) reduceAt book host = unsafeInterleaveIO $ do term <- reduceAt book host case tagT (termTag term) of ERA -> do return Era #304: LET -> do let loc = termLoc term let mode = modeT (termLab term) name <- genName state (loc + 0) val <- extractCoreAt state reduceAt book (loc + 1) bod <- extractCoreAt state reduceAt book (loc + 2) return $ Let mode name val bod #305: LAM -> do let loc = termLoc term name <- genName state (loc + 0) bod <- extractCoreAt state reduceAt book (loc + 1) return $ Lam name bod APP -> do let loc = termLoc term fun <- extractCoreAt state reduceAt book (loc + 0) arg <- extractCoreAt state reduceAt book (loc + 1) return $ App fun arg SUP -> do let loc = termLoc term let lab = termLab term tm0 <- extractCoreAt state reduceAt book (loc + 0) tm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Sup lab tm0 tm1 VAR -> do let key = termKey term name <- genName state key return $ Var name DP0 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp0) DP1 -> do let loc = termLoc term let lab = termLab term dups <- readIORef dupsRef if IS.member (fromIntegral loc) dups then do name <- genName state (termKey term) return $ Var name else do dp0 <- genName state (loc + 0) dp1 <- genName state (loc + 1) val <- extractCoreAt state reduceAt book (loc + 2) modifyIORef' dupsRef (IS.insert (fromIntegral loc)) return $ Dup lab dp0 dp1 val (Var dp1) #306: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab let ars = if ari == 0 then [] else [0..ari-1] fds <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) ars return $ Ctr cid fds MAT -> do let loc = termLoc term let len = termLab term val <- extractCoreAt state reduceAt book (loc + 0) css <- mapM (\i -> extractCoreAt state reduceAt book (loc + 1 + i)) [0..len-1] css <- mapM (\c -> return (0, c)) css -- NOTE: case arity lost on extraction return $ Mat val css W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- extractCoreAt state reduceAt book (loc + 0) nm1 <- extractCoreAt state reduceAt book (loc + 1) return $ Op2 opr nm0 nm1 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- mapM (\i -> extractCoreAt state reduceAt book (loc + i)) [0..ari-1] let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg _ -> do return Era #307: doExtractCoreAt :: ReduceAt -> Book -> Loc -> HVM Core doExtractCoreAt reduceAt book loc = do dupsRef <- newIORef IS.empty namsRef <- newIORef MS.empty let state = (dupsRef, namsRef) core <- extractCoreAt state reduceAt book loc return core -- return $ doLiftDups core #308: -- Lifting Dups -- ------------ #309: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #310: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #311: module HVML.Inject where #312: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #313: type InjectM a = StateT InjectState HVM a #314: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #315: emptyState :: InjectState emptyState = InjectState Map.empty [] #316: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #317: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #318: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #319: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #320: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #321: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #322: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #323: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #324: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #325: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #326: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #327: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #328: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

fdc66c2d5c2d02e50a7d2d24f7dd0112ce000b91

HVM3 will now collapse results with the `-C` flag Sups will be collapsed by generating multiple results. Example: @main = λt(t &0{1 2}) Will return 2 results: `λt(t 1)` and `λt(t 2)`. Dups will be collapsed by duplicating expressions. Example: @main = λf λx !&0{f0 f1}=f (f0 (f1 x)) Will return: `λf λx (f (f x))` HVM1 did the dup-collapsing by default, and we attempted to implement a sup-collapser as part of the program. I now realize that's the wrong approach, specially considering it requires a weird notion of SUP pattern-matching. Instead, Dup and Sup collapsing should be part of the outer language, allowing us to collapse a highly shared, highly superposed expression, into a list of results. Currently, the collapser will just do a DFS, but I'll add an option to perform BFS or even bring the priority queue approach (i.e., collapsing in order of label) to HVM3.

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #164: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #165: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #166: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #168: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #169: -- Constants -- --------- #170: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #171: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #172: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #173: //./Type.hs// #174: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #175: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #176: typedef _Atomic(Term) ATerm; #177: // Runtime Types // ------------- #178: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #179: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #180: // Constants // --------- #181: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #182: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #183: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #184: #define VOID 0x00000000000000 #185: // Heap // ---- #186: Loc get_len() { return *HVM.size; } #187: u64 get_itr() { return *HVM.itrs; } #188: void set_len(Loc value) { *HVM.size = value; } #189: void set_itr(Loc value) { *HVM.itrs = value; } #190: // Terms // ------ #191: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #192: Tag term_tag(Term x) { return x & 0xFF; } #193: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #194: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #195: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #196: // u12v2 // ----- #197: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #198: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #199: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #200: // Atomics // ------- #201: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #202: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #203: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #204: Term take(Loc loc) { return swap(loc, VOID); } #205: // Allocation // ---------- #206: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #207: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #208: // Stringification // --------------- #209: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #210: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #211: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #212: // Evaluation // ---------- #213: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #214: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #215: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #216: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #217: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #218: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #219: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #220: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #221: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #222: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #223: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #224: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #225: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #226: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #227: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #228: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #229: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #230: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #231: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #232: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #233: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #234: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #235: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #236: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #237: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #238: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #239: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #240: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #241: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #242: // Runtime Memory // -------------- #243: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #244: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #245: State* hvm_get_state() { return &HVM; } #246: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #247: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #248: -- //./Type.hs// #249: module HVML.Extract where #250: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #251: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #252: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #253: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #254: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #255: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #256: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #257: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #258: -- Lifting Dups -- ------------ #259: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #260: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #261: module HVML.Inject where #262: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #263: type InjectM a = StateT InjectState HVM a #264: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #265: emptyState :: InjectState emptyState = InjectState Map.empty [] #266: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #267: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #268: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #269: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #270: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #271: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #272: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #273: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #274: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #275: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #276: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #277: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #278: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Control.Monad.State import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_' <|> char '$') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, lexify (setRefIds nameToId' core)))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: -- Adds the function id to Ref constructors setRefIds :: MS.Map String Word64 -> Core -> Core setRefIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (setRefIds fids) arg) Let m x v b -> Let m x (setRefIds fids v) (setRefIds fids b) Lam x bod -> Lam x (setRefIds fids bod) App f x -> App (setRefIds fids f) (setRefIds fids x) Sup l x y -> Sup l (setRefIds fids x) (setRefIds fids y) Dup l x y v b -> Dup l x y (setRefIds fids v) (setRefIds fids b) Ctr cid fds -> Ctr cid (map (setRefIds fids) fds) Mat x css -> Mat (setRefIds fids x) (map (\ (ar,cs) -> (ar, setRefIds fids cs)) css) Op2 op x y -> Op2 op (setRefIds fids x) (setRefIds fids y) U32 n -> U32 n Era -> Era #45: -- Gives unique names to lexically scoped vars, unless they start with '$'. -- Example: `λx λt (t λx(x) x)` will read as `λx0 λt1 (t1 λx2(x2) x0)`. lexify :: Core -> Core lexify term = evalState (go term MS.empty) 0 where fresh :: String -> State Int String fresh nam@('$':_) = return $ nam fresh nam = do i <- get; put (i+1); return $ nam++"$"++show i #46: extend :: String -> String -> MS.Map String String -> State Int (MS.Map String String) extend old@('$':_) new ctx = return $ ctx extend old new ctx = return $ MS.insert old new ctx #47: go :: Core -> MS.Map String String -> State Int Core go term ctx = case term of Var nam -> return $ Var (MS.findWithDefault nam nam ctx) Ref nam fid arg -> do arg <- mapM (\x -> go x ctx) arg return $ Ref nam fid arg Let mod nam val bod -> do val <- go val ctx nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Let mod nam' val bod Lam nam bod -> do nam' <- fresh nam ctx <- extend nam nam' ctx bod <- go bod ctx return $ Lam nam' bod App fun arg -> do fun <- go fun ctx arg <- go arg ctx return $ App fun arg Sup lab tm0 tm1 -> do tm0 <- go tm0 ctx tm1 <- go tm1 ctx return $ Sup lab tm0 tm1 Dup lab dp0 dp1 val bod -> do val <- go val ctx dp0' <- fresh dp0 dp1' <- fresh dp1 ctx <- extend dp0 dp0' ctx ctx <- extend dp1 dp1' ctx bod <- go bod ctx return $ Dup lab dp0' dp1' val bod Ctr cid fds -> do fds <- mapM (\x -> go x ctx) fds return $ Ctr cid fds Mat val css -> do val <- go val ctx css <- mapM (\(ar, cs) -> do cs <- go cs ctx return (ar, cs)) css return $ Mat val css Op2 op nm0 nm1 -> do nm0 <- go nm0 ctx nm1 <- go nm1 ctx return $ Op2 op nm0 nm1 U32 n -> return $ U32 n Era -> return Era #48: -- Errors -- ------ #49: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #50: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #51: -- //./Type.hs// #52: module HVML.Reduce where #53: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #54: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #55: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do term <- got host if termBit term == 1 then do return term else do whnf <- reduceAt book host set host $ termSetBit whnf let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #56: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #57: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #58: -- //./Type.hs// -- //./Inject.hs// #59: module HVML.Compile where #60: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #61: import Debug.Trace #62: -- Compilation -- ----------- #63: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #64: type Compile = State CompileState #65: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #66: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #67: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #68: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #69: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #70: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #71: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #72: -- Full Compiler -- ------------- #73: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #74: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #75: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #76: -- Fast Compiler -- ------------- #77: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #78: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #79: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #80: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #81: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #82: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #83: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #84: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #85: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #86: -- Type.hs: -- //./Type.hs// #87: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #88: module Main where #89: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #90: import HVML.Collapse import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #91: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #92: -- Main -- ---- #93: main :: IO () main = do args <- getArgs result <- case args of ("run" : file : args) -> do let compiled = "-c" `elem` args let collapse = "-C" `elem` args let showStats = "-s" `elem` args cliRun file compiled collapse showStats ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #94: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-c] [-C] [-s] <file> # Normalizes the specified file" putStrLn " -c # Compile to native code" putStrLn " -C # Collapse the result" putStrLn " -s # Show statistics" putStrLn " hvml help # Shows this help message" return $ Right () #95: -- CLI Commands -- ------------ #96: cliRun :: FilePath -> Bool -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled collapse showStats = do -- Initialize the HVM hvmInit #97: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #98: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #99: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #100: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #101: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #102: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #103: -- Normalize main init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- if compiled then normalCAt book 0 else normalAt book 0 vals <- if collapse then do doCollapseCore book norm else do core <- doExtractCore book norm return [core] end <- getCPUTime #104: -- Print results forM_ vals $ \ term -> putStrLn $ coreToString term #105: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #106: -- Finalize hvmFree return $ Right () #107: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] ./Type.hs #108: -- //./Runtime.c// #109: module HVML.Type where #110: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #111: -- Core Types -- ---------- #112: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #113: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #114: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #115: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #116: type Func = ([String], Core) #117: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #118: -- Runtime Types -- ------------- #119: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #120: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #121: type HVM = IO #122: -- C Functions -- ----------- #123: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #124: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #125: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #126: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #127: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #129: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #130: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #131: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #132: foreign import ccall unsafe "Runtime.c term_bit" termBit :: Term -> Tag #133: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #134: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #135: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #136: foreign import ccall unsafe "Runtime.c term_set_bit" termSetBit :: Term -> Tag #137: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #138: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #139: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #140: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #168: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #169: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #170: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #171: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #172: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #173: -- Constants -- --------- #174: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #175: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #176: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #177: //./Type.hs// #178: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #179: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #180: typedef _Atomic(Term) ATerm; #181: // Runtime Types // ------------- #182: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #183: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #184: // Constants // --------- #185: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #186: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #187: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #188: #define VOID 0x00000000000000 #189: // Heap // ---- #190: Loc get_len() { return *HVM.size; } #191: u64 get_itr() { return *HVM.itrs; } #192: void set_len(Loc value) { *HVM.size = value; } #193: void set_itr(Loc value) { *HVM.itrs = value; } #194: // Terms // ------ #195: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #196: Tag term_tag(Term x) { return x & 0x7F; } #197: Tag term_bit(Term x) { return (x >> 7) & 1; } #198: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #199: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #200: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #201: Term term_set_bit(Term term) { return term | (1ULL << 7); } #202: // u12v2 // ----- #203: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #204: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #205: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #206: // Atomics // ------- #207: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #208: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #209: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #210: Term take(Loc loc) { return swap(loc, VOID); } #211: // Allocation // ---------- #212: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #213: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #214: // Stringification // --------------- #215: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #216: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #217: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #218: // Evaluation // ---------- #219: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #220: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #221: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #222: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #223: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #224: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #225: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #226: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #227: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #228: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #229: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #230: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #231: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #232: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #233: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #234: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #235: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #236: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #237: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #238: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #239: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #240: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #241: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #242: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #243: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #244: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #245: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #246: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #247: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #248: // Runtime Memory // -------------- #249: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #250: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #251: State* hvm_get_state() { return &HVM; } #252: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #253: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #254: -- //./Type.hs// #255: module HVML.Extract where #256: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #257: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #258: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #259: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #260: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #261: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #262: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #263: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #264: -- Lifting Dups -- ------------ #265: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #266: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #267: module HVML.Inject where #268: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #269: type InjectM a = StateT InjectState HVM a #270: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #271: emptyState :: InjectState emptyState = InjectState Map.empty [] #272: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #273: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #274: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #275: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #276: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #277: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #278: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #279: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #280: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #281: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #282: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #283: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #284: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

8b4edab03eac854e7d7c53471550c3a1e26c841d

move unord sups to another branch

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #164: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #165: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #166: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #168: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #169: -- Constants -- --------- #170: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #171: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #172: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #173: //./Type.hs// #174: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #175: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #176: typedef _Atomic(Term) ATerm; #177: // Runtime Types // ------------- #178: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #179: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #180: // Constants // --------- #181: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #182: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #183: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #184: #define VOID 0x00000000000000 #185: // Heap // ---- #186: Loc get_len() { return *HVM.size; } #187: u64 get_itr() { return *HVM.itrs; } #188: void set_len(Loc value) { *HVM.size = value; } #189: void set_itr(Loc value) { *HVM.itrs = value; } #190: // Terms // ------ #191: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #192: Tag term_tag(Term x) { return x & 0xFF; } #193: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #194: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #195: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #196: // u12v2 // ----- #197: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #198: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #199: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #200: // Atomics // ------- #201: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #202: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #203: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #204: Term take(Loc loc) { return swap(loc, VOID); } #205: // Allocation // ---------- #206: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #207: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #208: // Stringification // --------------- #209: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #210: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #211: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #212: // Evaluation // ---------- #213: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #214: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #215: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #216: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #217: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #218: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #219: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #220: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #221: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #222: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #223: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #224: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #225: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #226: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #227: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #228: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #229: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #230: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #231: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #232: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #233: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #234: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #235: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #236: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #237: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #238: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #239: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #240: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #241: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #242: // Runtime Memory // -------------- #243: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #244: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #245: State* hvm_get_state() { return &HVM; } #246: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #247: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #248: -- //./Type.hs// #249: module HVML.Extract where #250: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #251: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #252: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #253: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #254: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #255: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #256: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #257: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #258: -- Lifting Dups -- ------------ #259: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #260: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #261: module HVML.Inject where #262: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #263: type InjectM a = StateT InjectState HVM a #264: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #265: emptyState :: InjectState emptyState = InjectState Map.empty [] #266: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #267: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #268: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #269: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #270: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #271: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #272: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #273: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #274: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #275: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #276: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #277: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #278: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" next <- lookAhead anyChar case next of '#' -> do -- Parse ADT constructor case consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) _ -> do -- Parse U32 or named case name <- parseName cid <- case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> return 0xFFFFFFFF consume ":" cas <- if cid == 0xFFFFFFFF then do body <- parseCore return $ Lam name body else do parseCore return (cid, (-1, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #164: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #165: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #166: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #168: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #169: -- Constants -- --------- #170: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #171: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #172: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #173: //./Type.hs// #174: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #175: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #176: typedef _Atomic(Term) ATerm; #177: // Runtime Types // ------------- #178: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #179: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #180: // Constants // --------- #181: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #182: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #183: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #184: #define VOID 0x00000000000000 #185: // Heap // ---- #186: Loc get_len() { return *HVM.size; } #187: u64 get_itr() { return *HVM.itrs; } #188: void set_len(Loc value) { *HVM.size = value; } #189: void set_itr(Loc value) { *HVM.itrs = value; } #190: // Terms // ------ #191: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #192: Tag term_tag(Term x) { return x & 0xFF; } #193: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #194: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #195: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #196: // u12v2 // ----- #197: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #198: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #199: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #200: // Atomics // ------- #201: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #202: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #203: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #204: Term take(Loc loc) { return swap(loc, VOID); } #205: // Allocation // ---------- #206: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #207: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #208: // Stringification // --------------- #209: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #210: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #211: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #212: // Evaluation // ---------- #213: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #214: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #215: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #216: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #217: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #218: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #219: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #220: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #221: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #222: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #223: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #224: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #225: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #226: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #227: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #228: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #229: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #230: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #231: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #232: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #233: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #234: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #235: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #236: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #237: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #238: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #239: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #240: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #241: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #242: // Runtime Memory // -------------- #243: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #244: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #245: State* hvm_get_state() { return &HVM; } #246: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #247: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #248: -- //./Type.hs// #249: module HVML.Extract where #250: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #251: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #252: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #253: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #254: CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #255: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #256: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #257: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #258: -- Lifting Dups -- ------------ #259: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod #260: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #261: module HVML.Inject where #262: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #263: type InjectM a = StateT InjectState HVM a #264: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #265: emptyState :: InjectState emptyState = InjectState Map.empty [] #266: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #267: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #268: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #269: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #270: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #271: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #272: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #273: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #274: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #275: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #276: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #277: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #278: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

8f1749c45d7cd3cf3ce37636337d6aec791942fd

oportunistic swap fix - dont subs

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Suh lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Duh lab dp0 dp1 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Suh lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Duh lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Suh l x y -> Suh l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Duh l x y v b -> Duh l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) SUH -> cont host (reduceAppSuh term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do -- putStrLn "NOPES" return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) SUH -> cont host (reduceMatSuh term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) SUH -> cont host (reduceOpxSuh term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) SUH -> cont host (reduceOpySuh term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf SUH -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf DH0 -> do normalAtWith reduceAt book (loc + 2) return whnf DH1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Suh lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Duh lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Suh lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Duh lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Suh Word64 Core Core | Dup Word64 String String Core Core | Duh Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | DH0 | DH1 | VAR | APP | ERA | LAM | SUP | SUH | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_suh" reduceAppSuh :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_suh" reduceDupSuh :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_suh" reduceMatSuh :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_suh" reduceOpxSuh :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_suh" reduceOpySuh :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_duh_era" reduceDuhEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_duh_lam" reduceDuhLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_duh_sup" reduceDuhSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_duh_ctr" reduceDuhCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_duh_w32" reduceDuhW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_duh_suh" reduceDuhSuh :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c reduce_duh_duh" reduceDuhDuh :: Term -> Term -> IO Term #175: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #176: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #177: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #178: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #180: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #181: -- Constants -- --------- #182: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = DH0 tagT 0x03 = DH1 tagT 0x04 = VAR tagT 0x05 = SUB tagT 0x06 = REF tagT 0x07 = LET tagT 0x08 = APP tagT 0x09 = MAT tagT 0x0A = OPX tagT 0x0B = OPY tagT 0x0C = ERA tagT 0x0D = LAM tagT 0x0E = SUP tagT 0x0F = SUH tagT 0x10 = CTR tagT 0x11 = W32 tagT tag = error $ "unknown tag: " ++ show tag #183: _DP0_, _DP1_, _VAR_, _SUB_, _DH0_, _DH1_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _SUH_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _DH0_ = 0x02 _DH1_ = 0x03 _VAR_ = 0x04 _SUB_ = 0x05 _REF_ = 0x06 _LET_ = 0x07 _APP_ = 0x08 _MAT_ = 0x09 _OPX_ = 0x0A _OPY_ = 0x0B _ERA_ = 0x0C _LAM_ = 0x0D _SUP_ = 0x0E _SUH_ = 0x0F _CTR_ = 0x10 _W32_ = 0x11 #184: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #185: //./Type.hs// #186: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #187: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #188: typedef _Atomic(Term) ATerm; #189: // Runtime Types // ------------- #190: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #191: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #192: // Constants // --------- #193: #define DP0 0x00 #define DP1 0x01 #define DH0 0x02 #define DH1 0x03 #define VAR 0x04 #define SUB 0x05 #define REF 0x06 #define LET 0x07 #define APP 0x08 #define MAT 0x09 #define OPX 0x0A #define OPY 0x0B #define ERA 0x0C #define LAM 0x0D #define SUP 0x0E #define SUH 0x0F #define CTR 0x10 #define W32 0x11 #194: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #195: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #196: #define VOID 0x00000000000000 #197: // Heap // ---- #198: Loc get_len() { return *HVM.size; } #199: u64 get_itr() { return *HVM.itrs; } #200: void set_len(Loc value) { *HVM.size = value; } #201: void set_itr(Loc value) { *HVM.itrs = value; } #202: // Terms // ------ #203: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #204: Tag term_tag(Term x) { return x & 0xFF; } #205: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #206: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #207: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case DH0: return term_loc(term) + 0; case DH1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #208: // u12v2 // ----- #209: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #210: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #211: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #212: // Atomics // ------- #213: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #214: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #215: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #216: Term take(Loc loc) { return swap(loc, VOID); } #217: // Allocation // ---------- #218: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #219: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #220: // Stringification // --------------- #221: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case DH0: printf("DH0"); break; case DH1: printf("DH1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case SUH: printf("SUH"); break; default : printf("???"); break; } } #222: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #223: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #224: // Evaluation // ---------- #225: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #226: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #227: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #228: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #229: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #230: // ,----------------,---------------, // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : /_\y a/#\ : /_\y /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // :----------------|---------------| // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : x /_\ a/#\ : x /_\ /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // '----------------'---------------' //A: //- in = 0 //- up = 0 //- put = 1 = !in //- mof = 0 = up //- ret = 0 = in #231: //B: //- in = 1 //- up = 0 //- put = 0 = !in //- mof = 0 = up //- ret = 1 = in #232: //C: //- in = 0 //- up = 1 //- put = 1 = !in //- mof = 1 = up //- ret = 0 = in #233: //D: //- in = 1 //- up = 1 //- put = 0 = !in //- mof = 1 = up //- ret = 1 = in #234: // %L{y0 y1} = v // %L{x0 x1} = y0 // --------------- DUH_DUH // %L{x0 x1} = v // %L{y0 y1} = y0 // x1 <- y0 Term reduce_duh_duh(Term bot, Term top) { Loc bot_loc = term_loc(bot); Lab bot_lab = term_lab(bot); Loc top_loc = term_loc(top); Loc top_lab = term_lab(top); Term bot_val = got(bot_loc + 2); Term top_val = got(top_loc + 2); Tag in_A = term_tag(bot) == DH0 ? 0 : 1; Tag in_B = 1 - in_A; Tag up_A = term_tag(bot_val) == DH0 ? 0 : 1; Tag up_B = 1 - up_A; Loc new_duh = alloc_node(3); set(new_duh + 0, term_new(SUB, 0, 0)); set(new_duh + 1, term_new(SUB, 0, 0)); set(new_duh + 2, top_val); set(top_loc + up_A, term_new(SUB, 0, 0)); set(top_loc + 2 , term_new(DH0+in_B, bot_lab, new_duh)); set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); return term_new(DH0+in_A, bot_lab, new_duh); } #235: // (%L{a b} c) // ----------------- APP-SUP // ! %L{x0 x1} = c // %L{(a x0) (b x1)} Term reduce_app_suh(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DH0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUH, sup_lab, su0); } #236: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #237: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #238: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #239: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #240: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #241: // ! &L{x y} = %R{a b} // ------------------- DUP-SUH // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } #242: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #243: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #244: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #245: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #246: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #247: // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUH // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_suh(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DH0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DH1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUH, sup_lab, sup0); } #248: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #249: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #250: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #251: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #252: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #253: // <op(%L{x0 x1} y) // ------------------------- OPX-SUH // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_suh(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DH0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUH, sup_lab, su0); } #254: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #255: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #256: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #257: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #258: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #259: // >op(a %L{x y}) // --------------------- OPY-SUH // %L{>op(a x) >op(a y)} Term reduce_opy_suh(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUH, sup_lab, su0); } #260: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #261: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #262: // ! %L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_duh_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #263: // ! %L{r s} = λx(f) // ----------------- DUP-LAM // ! %L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- %L{x0 x1} Term reduce_duh_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DH0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DH1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUH, dup_lab, su0)); return got(dup_loc + dup_num); } #264: // ! %L{x y} = &R{a b} // ------------------- DUP-SUP // x <- &R{a0 b0} // y <- &R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } #265: // ! %L{x y} = %R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- %R{a0 b0} // y <- %R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } } #266: // ! %L{x y} = #{a b c ...} // ------------------------ DUH-CTR // ! %L{a0 a1} = a // ! %L{b0 b1} = b // ! %L{c0 c1} = c // ... // %L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_duh_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DH0, dup_lab, du0)); set(ctr1 + i, term_new(DH1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #267: // ! %L{x y} = 123 // --------------- DUH-W32 // x <- 123 // y <- 123 Term reduce_duh_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #268: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case DH0: case DH1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { Term prev = next; next = got(loc + 2); Tag ntag = term_tag(next); Lab nlab = term_lab(next); Loc nloc = term_loc(next); if ((ntag == DH0 || ntag == DH1) && lab == nlab) { Loc nkey = term_key(next); Term nsub = got(nkey); if (term_tag(nsub) == SUB) { next = reduce_duh_duh(prev, next); continue; } } HVM.sbuf[(*spos)++] = prev; continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case SUH: next = reduce_app_suh(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case SUH: next = reduce_dup_suh(prev, next); continue; default: break; } break; } case DH0: case DH1: { switch (tag) { case ERA: next = reduce_duh_era(prev, next); continue; case LAM: next = reduce_duh_lam(prev, next); continue; case SUP: next = reduce_duh_sup(prev, next); continue; case CTR: next = reduce_duh_ctr(prev, next); continue; case W32: next = reduce_duh_w32(prev, next); continue; case SUH: next = reduce_duh_suh(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case SUH: next = reduce_mat_suh(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case SUH: next = reduce_opx_suh(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case SUH: next = reduce_opy_suh(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #269: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case SUH: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case DH0: case DH1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #270: // Runtime Memory // -------------- #271: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #272: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #273: State* hvm_get_state() { return &HVM; } #274: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #275: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #276: -- //./Type.hs// #277: module HVML.Extract where #278: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #279: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #280: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #281: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #282: DH0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh0) else extractCore book sub DH1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh1) else extractCore book sub #283: SUH -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Suh lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #284: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #285: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #286: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #287: -- Lifting Dups -- ------------ #288: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (Suh lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Suh lab tm0 tm1 liftDups (Duh lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Duh lab dp0 dp1 val k)) return bod #289: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #290: module HVML.Inject where #291: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #292: type InjectM a = StateT InjectState HVM a #293: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #294: emptyState :: InjectState emptyState = InjectState Map.empty [] #295: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #296: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #297: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #298: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #299: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #300: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #301: injectCore book (Suh lab tm0 tm1) loc = do suh <- lift $ allocNode 2 injectCore book tm0 (suh + 0) injectCore book tm1 (suh + 1) lift $ set loc (termNew _SUH_ lab suh) #302: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #303: injectCore book (Duh lab dh0 dh1 val bod) loc = do duh <- lift $ allocNode 3 lift $ set (duh + 0) (termNew _SUB_ 0 0) lift $ set (duh + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dh0 (termNew _DH0_ lab duh) $ Map.insert dh1 (termNew _DH1_ lab duh) (args s) } injectCore book val (duh + 2) injectCore book bod loc #304: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #305: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #306: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #307: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #308: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #309: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Suh lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Duh lab dp0 dp1 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Suh lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Duh lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Suh l x y -> Suh l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Duh l x y v b -> Duh l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) SUH -> cont host (reduceAppSuh term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) -- let isChain = False isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do -- putStrLn "NOPES" return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) SUH -> cont host (reduceMatSuh term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) SUH -> cont host (reduceOpxSuh term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) SUH -> cont host (reduceOpySuh term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf SUH -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf DH0 -> do normalAtWith reduceAt book (loc + 2) return whnf DH1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Suh lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Duh lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Suh lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Duh lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Suh Word64 Core Core | Dup Word64 String String Core Core | Duh Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | DH0 | DH1 | VAR | APP | ERA | LAM | SUP | SUH | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_suh" reduceAppSuh :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_suh" reduceDupSuh :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_suh" reduceMatSuh :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_suh" reduceOpxSuh :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_suh" reduceOpySuh :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_duh_era" reduceDuhEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_duh_lam" reduceDuhLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_duh_sup" reduceDuhSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_duh_ctr" reduceDuhCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_duh_w32" reduceDuhW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_duh_suh" reduceDuhSuh :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c reduce_duh_duh" reduceDuhDuh :: Term -> Term -> IO Term #175: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #176: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #177: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #178: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #180: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #181: -- Constants -- --------- #182: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = DH0 tagT 0x03 = DH1 tagT 0x04 = VAR tagT 0x05 = SUB tagT 0x06 = REF tagT 0x07 = LET tagT 0x08 = APP tagT 0x09 = MAT tagT 0x0A = OPX tagT 0x0B = OPY tagT 0x0C = ERA tagT 0x0D = LAM tagT 0x0E = SUP tagT 0x0F = SUH tagT 0x10 = CTR tagT 0x11 = W32 tagT tag = error $ "unknown tag: " ++ show tag #183: _DP0_, _DP1_, _VAR_, _SUB_, _DH0_, _DH1_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _SUH_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _DH0_ = 0x02 _DH1_ = 0x03 _VAR_ = 0x04 _SUB_ = 0x05 _REF_ = 0x06 _LET_ = 0x07 _APP_ = 0x08 _MAT_ = 0x09 _OPX_ = 0x0A _OPY_ = 0x0B _ERA_ = 0x0C _LAM_ = 0x0D _SUP_ = 0x0E _SUH_ = 0x0F _CTR_ = 0x10 _W32_ = 0x11 #184: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #185: //./Type.hs// #186: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #187: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #188: typedef _Atomic(Term) ATerm; #189: // Runtime Types // ------------- #190: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #191: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #192: // Constants // --------- #193: #define DP0 0x00 #define DP1 0x01 #define DH0 0x02 #define DH1 0x03 #define VAR 0x04 #define SUB 0x05 #define REF 0x06 #define LET 0x07 #define APP 0x08 #define MAT 0x09 #define OPX 0x0A #define OPY 0x0B #define ERA 0x0C #define LAM 0x0D #define SUP 0x0E #define SUH 0x0F #define CTR 0x10 #define W32 0x11 #194: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #195: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #196: #define VOID 0x00000000000000 #197: // Heap // ---- #198: Loc get_len() { return *HVM.size; } #199: u64 get_itr() { return *HVM.itrs; } #200: void set_len(Loc value) { *HVM.size = value; } #201: void set_itr(Loc value) { *HVM.itrs = value; } #202: // Terms // ------ #203: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #204: Tag term_tag(Term x) { return x & 0xFF; } #205: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #206: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #207: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case DH0: return term_loc(term) + 0; case DH1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #208: // u12v2 // ----- #209: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #210: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #211: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #212: // Atomics // ------- #213: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #214: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #215: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #216: Term take(Loc loc) { return swap(loc, VOID); } #217: // Allocation // ---------- #218: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #219: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #220: // Stringification // --------------- #221: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case DH0: printf("DH0"); break; case DH1: printf("DH1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case SUH: printf("SUH"); break; default : printf("???"); break; } } #222: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #223: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #224: // Evaluation // ---------- #225: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #226: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #227: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #228: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #229: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #230: // ,----------------,---------------, // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : /_\y /#\a : /_\y /#\b : // : | | | |↑ : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // :----------------|---------------| // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : x /_\ a/#\ : x /_\ /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // '----------------'---------------' #231: // ,---------------, // : v : // : | : // : v /_\ : // : | | | : // : /#\ /#\a : // : | | | | : // : /_\y /_\y : // : | | | | : // : a b * b : // : ↑ : // '---------------' #232: //A: //- in = 0 //- up = 0 //- put = 1 = !in //- mof = 0 = up //- ret = 0 = in #233: //B: //- in = 1 //- up = 0 //- put = 0 = !in //- mof = 0 = up //- ret = 1 = in #234: //C: //- in = 0 //- up = 1 //- put = 1 = !in //- mof = 1 = up //- ret = 0 = in #235: //D: //- in = 1 //- up = 1 //- put = 0 = !in //- mof = 1 = up //- ret = 1 = in #236: // %L{y0 y1} = v // %L{x0 x1} = y0 // --------------- DUH_DUH // %L{x0 x1} = v // %L{y0 y1} = y0 // x1 <- y0 Term reduce_duh_duh(Term bot, Term top) { inc_itr(); Loc bot_loc = term_loc(bot); Lab bot_lab = term_lab(bot); Loc top_loc = term_loc(top); Loc top_lab = term_lab(top); Term bot_val = got(bot_loc + 2); Term top_val = got(top_loc + 2); Tag in_A = term_tag(bot) == DH0 ? 0 : 1; Tag up_A = term_tag(bot_val) == DH0 ? 0 : 1; Loc new_duh = alloc_node(3); #237: //set(new_duh + 0, term_new(SUB, 0, 0)); //set(new_duh + 1, term_new(SUB, 0, 0)); //set(new_duh + 2, top_val); //set(top_loc + up_A, term_new(SUB, 0, 0)); //set(top_loc + 2 , term_new(DH0+in_B, bot_lab, new_duh)); //set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); //return term_new(DH0+in_A, bot_lab, new_duh); #238: //u32 PUT = in_A; //u32 MOF = up_A; //u32 RET = in_B; #239: //u32 PUT = in_A; //u32 MOF = up_A; //u32 RET = in_B; //set(new_duh + 0, term_new(SUB, 0, 0)); //set(new_duh + 1, term_new(SUB, 0, 0)); //set(new_duh + 2, top_val); //set(top_loc + MOF, term_new(SUB, 0, 0)); //set(top_loc + 2 , term_new(DH0+PUT, bot_lab, new_duh)); //set(bot_loc + PUT, term_new(DH0+MOF, bot_lab, top_loc)); //return term_new(DH0+RET, bot_lab, new_duh); #240: u32 PUT = in_A; set(new_duh + 0, term_new(SUB, 0, 0)); set(new_duh + 1, term_new(SUB, 0, 0)); set(new_duh + 2, top_val); set(top_loc + up_A, term_new(SUB, 0, 0)); set(top_loc + 2 , term_new(DH0+PUT, bot_lab, new_duh)); return term_new(DH0+!PUT, bot_lab, new_duh); #241: // CORRECT //u32 PUT = in_A; //set(new_duh + 0, term_new(SUB, 0, 0)); //set(new_duh + 1, term_new(SUB, 0, 0)); //set(new_duh + 2, top_val); //set(top_loc + up_A, term_new(SUB, 0, 0)); //set(top_loc + 2 , term_new(DH0+PUT, bot_lab, new_duh)); //set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); //return term_new(DH0+!PUT, bot_lab, new_duh); #242: } #243: // (%L{a b} c) // ----------------- APP-SUP // ! %L{x0 x1} = c // %L{(a x0) (b x1)} Term reduce_app_suh(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DH0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUH, sup_lab, su0); } #244: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #245: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #246: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #247: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #248: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #249: // ! &L{x y} = %R{a b} // ------------------- DUP-SUH // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } #250: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #251: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #252: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #253: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #254: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #255: // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUH // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_suh(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DH0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DH1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUH, sup_lab, sup0); } #256: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #257: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #258: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #259: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #260: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #261: // <op(%L{x0 x1} y) // ------------------------- OPX-SUH // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_suh(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DH0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUH, sup_lab, su0); } #262: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #263: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #264: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #265: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #266: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #267: // >op(a %L{x y}) // --------------------- OPY-SUH // %L{>op(a x) >op(a y)} Term reduce_opy_suh(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUH, sup_lab, su0); } #268: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #269: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #270: // ! %L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_duh_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #271: // ! %L{r s} = λx(f) // ----------------- DUP-LAM // ! %L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- %L{x0 x1} Term reduce_duh_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DH0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DH1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUH, dup_lab, su0)); return got(dup_loc + dup_num); } #272: // ! %L{x y} = &R{a b} // ------------------- DUP-SUP // x <- &R{a0 b0} // y <- &R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } #273: // ! %L{x y} = %R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- %R{a0 b0} // y <- %R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } } #274: // ! %L{x y} = #{a b c ...} // ------------------------ DUH-CTR // ! %L{a0 a1} = a // ! %L{b0 b1} = b // ! %L{c0 c1} = c // ... // %L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_duh_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DH0, dup_lab, du0)); set(ctr1 + i, term_new(DH1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #275: // ! %L{x y} = 123 // --------------- DUH-W32 // x <- 123 // y <- 123 Term reduce_duh_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #276: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case DH0: case DH1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { Term prev = next; next = got(loc + 2); Tag ntag = term_tag(next); Lab nlab = term_lab(next); Loc nloc = term_loc(next); if ((ntag == DH0 || ntag == DH1) && lab == nlab) { Loc nkey = term_key(next); Term nsub = got(nkey); if (term_tag(nsub) == SUB) { next = reduce_duh_duh(prev, next); continue; } } HVM.sbuf[(*spos)++] = prev; continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case SUH: next = reduce_app_suh(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case SUH: next = reduce_dup_suh(prev, next); continue; default: break; } break; } case DH0: case DH1: { switch (tag) { case ERA: next = reduce_duh_era(prev, next); continue; case LAM: next = reduce_duh_lam(prev, next); continue; case SUP: next = reduce_duh_sup(prev, next); continue; case CTR: next = reduce_duh_ctr(prev, next); continue; case W32: next = reduce_duh_w32(prev, next); continue; case SUH: next = reduce_duh_suh(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case SUH: next = reduce_mat_suh(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case SUH: next = reduce_opx_suh(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case SUH: next = reduce_opy_suh(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #277: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case SUH: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case DH0: case DH1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #278: // Runtime Memory // -------------- #279: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #280: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #281: State* hvm_get_state() { return &HVM; } #282: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #283: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #284: -- //./Type.hs// #285: module HVML.Extract where #286: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #287: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #288: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #289: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #290: DH0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh0) else extractCore book sub DH1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh1) else extractCore book sub #291: SUH -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Suh lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #292: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #293: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #294: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #295: -- Lifting Dups -- ------------ #296: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (Suh lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Suh lab tm0 tm1 liftDups (Duh lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Duh lab dp0 dp1 val k)) return bod #297: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #298: module HVML.Inject where #299: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #300: type InjectM a = StateT InjectState HVM a #301: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #302: emptyState :: InjectState emptyState = InjectState Map.empty [] #303: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #304: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #305: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #306: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #307: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #308: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #309: injectCore book (Suh lab tm0 tm1) loc = do suh <- lift $ allocNode 2 injectCore book tm0 (suh + 0) injectCore book tm1 (suh + 1) lift $ set loc (termNew _SUH_ lab suh) #310: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #311: injectCore book (Duh lab dh0 dh1 val bod) loc = do duh <- lift $ allocNode 3 lift $ set (duh + 0) (termNew _SUB_ 0 0) lift $ set (duh + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dh0 (termNew _DH0_ lab duh) $ Map.insert dh1 (termNew _DH1_ lab duh) (args s) } injectCore book val (duh + 2) injectCore book bod loc #312: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #313: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #314: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #315: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #316: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #317: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

1f241a65469d23cee22c450f6061e2ed2e578223

fix bug on dup-swap toggle when swapping unordered dup nodes, we must check if the parent node hasn't been substituted already, to confirm it is indeed a dup the code is very messy right now and must be cleaned up

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Suh lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Duh lab dp0 dp1 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Suh lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Duh lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Suh l x y -> Suh l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Duh l x y v b -> Duh l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do term <- got host -- root <- got 0 -- root <- doExtractCore book root -- core <- doExtractCore book term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core -- putStrLn $ "---------------- ROOT: " -- putStrLn $ coreToString root -- putStrLn $ "reduce " ++ termToString term let tag = termTag term let lab = termLab term let loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) SUH -> cont host (reduceAppSuh term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vlab = termLab val let vtag = tagT (termTag val) if (vtag == DH0 || vtag == DH1) && vlab == lab then do cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vlab = termLab val let vtag = tagT (termTag val) if (vtag == DH0 || vtag == DH1) && vlab == lab then do cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) SUH -> cont host (reduceMatSuh term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) SUH -> cont host (reduceOpxSuh term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) SUH -> cont host (reduceOpySuh term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf SUH -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf DH0 -> do normalAtWith reduceAt book (loc + 2) return whnf DH1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Suh lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Duh lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Suh lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Duh lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Suh Word64 Core Core | Dup Word64 String String Core Core | Duh Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | DH0 | DH1 | VAR | APP | ERA | LAM | SUP | SUH | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_suh" reduceAppSuh :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_suh" reduceDupSuh :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_suh" reduceMatSuh :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_suh" reduceOpxSuh :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_suh" reduceOpySuh :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_duh_era" reduceDuhEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_duh_lam" reduceDuhLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_duh_sup" reduceDuhSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_duh_ctr" reduceDuhCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_duh_w32" reduceDuhW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_duh_suh" reduceDuhSuh :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c reduce_duh_duh" reduceDuhDuh :: Term -> Term -> IO Term #175: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #176: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #177: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #178: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #180: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #181: -- Constants -- --------- #182: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = DH0 tagT 0x03 = DH1 tagT 0x04 = VAR tagT 0x05 = SUB tagT 0x06 = REF tagT 0x07 = LET tagT 0x08 = APP tagT 0x09 = MAT tagT 0x0A = OPX tagT 0x0B = OPY tagT 0x0C = ERA tagT 0x0D = LAM tagT 0x0E = SUP tagT 0x0F = SUH tagT 0x10 = CTR tagT 0x11 = W32 tagT tag = error $ "unknown tag: " ++ show tag #183: _DP0_, _DP1_, _VAR_, _SUB_, _DH0_, _DH1_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _SUH_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _DH0_ = 0x02 _DH1_ = 0x03 _VAR_ = 0x04 _SUB_ = 0x05 _REF_ = 0x06 _LET_ = 0x07 _APP_ = 0x08 _MAT_ = 0x09 _OPX_ = 0x0A _OPY_ = 0x0B _ERA_ = 0x0C _LAM_ = 0x0D _SUP_ = 0x0E _SUH_ = 0x0F _CTR_ = 0x10 _W32_ = 0x11 #184: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #185: //./Type.hs// #186: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #187: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #188: typedef _Atomic(Term) ATerm; #189: // Runtime Types // ------------- #190: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #191: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #192: // Constants // --------- #193: #define DP0 0x00 #define DP1 0x01 #define DH0 0x02 #define DH1 0x03 #define VAR 0x04 #define SUB 0x05 #define REF 0x06 #define LET 0x07 #define APP 0x08 #define MAT 0x09 #define OPX 0x0A #define OPY 0x0B #define ERA 0x0C #define LAM 0x0D #define SUP 0x0E #define SUH 0x0F #define CTR 0x10 #define W32 0x11 #194: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #195: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #196: #define VOID 0x00000000000000 #197: // Heap // ---- #198: Loc get_len() { return *HVM.size; } #199: u64 get_itr() { return *HVM.itrs; } #200: void set_len(Loc value) { *HVM.size = value; } #201: void set_itr(Loc value) { *HVM.itrs = value; } #202: // Terms // ------ #203: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #204: Tag term_tag(Term x) { return x & 0xFF; } #205: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #206: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #207: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case DH0: return term_loc(term) + 0; case DH1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #208: // u12v2 // ----- #209: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #210: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #211: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #212: // Atomics // ------- #213: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #214: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #215: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #216: Term take(Loc loc) { return swap(loc, VOID); } #217: // Allocation // ---------- #218: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #219: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #220: // Stringification // --------------- #221: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case DH0: printf("DH0"); break; case DH1: printf("DH1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case SUH: printf("SUH"); break; default : printf("???"); break; } } #222: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #223: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #224: // Evaluation // ---------- #225: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #226: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #227: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #228: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #229: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #230: // ,----------------,---------------, // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : /_\y a/#\ : /_\y /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // :----------------|---------------| // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : x /_\ a/#\ : x /_\ /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // '----------------'---------------' //A: //- in = 0 //- up = 0 //- put = 1 = !in //- mof = 0 = up //- ret = 0 = in #231: //B: //- in = 1 //- up = 0 //- put = 0 = !in //- mof = 0 = up //- ret = 1 = in #232: //C: //- in = 0 //- up = 1 //- put = 1 = !in //- mof = 1 = up //- ret = 0 = in #233: //D: //- in = 1 //- up = 1 //- put = 0 = !in //- mof = 1 = up //- ret = 1 = in #234: // %L{y0 y1} = v // %L{x0 x1} = y0 // --------------- DUH_DUH // %L{x0 x1} = v // %L{y0 y1} = y0 // x1 <- y0 Term reduce_duh_duh(Term bot, Term top) { Loc bot_loc = term_loc(bot); Lab bot_lab = term_lab(bot); Loc top_loc = term_loc(top); Loc top_lab = term_lab(top); Term bot_val = got(bot_loc + 2); Term top_val = got(top_loc + 2); Tag in_A = term_tag(bot) == DH0 ? 0 : 1; Tag in_B = 1 - in_A; Tag up_A = term_tag(bot_val) == DH0 ? 0 : 1; Tag up_B = 1 - up_A; Loc new_duh = alloc_node(3); set(new_duh + 0, term_new(SUB, 0, 0)); set(new_duh + 1, term_new(SUB, 0, 0)); set(new_duh + 2, top_val); set(top_loc + up_A, term_new(SUB, 0, 0)); set(top_loc + 2 , term_new(DH0+in_B, bot_lab, new_duh)); set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); return term_new(DH0+in_A, bot_lab, new_duh); } #235: // (%L{a b} c) // ----------------- APP-SUP // ! %L{x0 x1} = c // %L{(a x0) (b x1)} Term reduce_app_suh(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DH0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUH, sup_lab, su0); } #236: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #237: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #238: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #239: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #240: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #241: // ! &L{x y} = %R{a b} // ------------------- DUP-SUH // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } #242: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #243: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #244: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #245: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #246: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #247: // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUH // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_suh(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DH0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DH1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUH, sup_lab, sup0); } #248: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #249: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #250: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #251: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #252: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #253: // <op(%L{x0 x1} y) // ------------------------- OPX-SUH // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_suh(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DH0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUH, sup_lab, su0); } #254: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #255: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #256: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #257: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #258: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #259: // >op(a %L{x y}) // --------------------- OPY-SUH // %L{>op(a x) >op(a y)} Term reduce_opy_suh(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUH, sup_lab, su0); } #260: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #261: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #262: // ! %L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_duh_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #263: // ! %L{r s} = λx(f) // ----------------- DUP-LAM // ! %L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- %L{x0 x1} Term reduce_duh_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DH0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DH1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUH, dup_lab, su0)); return got(dup_loc + dup_num); } #264: // ! %L{x y} = &R{a b} // ------------------- DUP-SUP // x <- &R{a0 b0} // y <- &R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } #265: // ! %L{x y} = %R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- %R{a0 b0} // y <- %R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } } #266: // ! %L{x y} = #{a b c ...} // ------------------------ DUH-CTR // ! %L{a0 a1} = a // ! %L{b0 b1} = b // ! %L{c0 c1} = c // ... // %L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_duh_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DH0, dup_lab, du0)); set(ctr1 + i, term_new(DH1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #267: // ! %L{x y} = 123 // --------------- DUH-W32 // x <- 123 // y <- 123 Term reduce_duh_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #268: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case DH0: case DH1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { Term prev = next; next = got(loc + 2); Tag ntag = term_tag(next); Lab nlab = term_lab(next); Loc nloc = term_loc(next); if ((ntag == DH0 || ntag == DH1) && lab == nlab) { next = reduce_duh_duh(prev, next); continue; } HVM.sbuf[(*spos)++] = prev; continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case SUH: next = reduce_app_suh(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case SUH: next = reduce_dup_suh(prev, next); continue; default: break; } break; } case DH0: case DH1: { switch (tag) { case ERA: next = reduce_duh_era(prev, next); continue; case LAM: next = reduce_duh_lam(prev, next); continue; case SUP: next = reduce_duh_sup(prev, next); continue; case CTR: next = reduce_duh_ctr(prev, next); continue; case W32: next = reduce_duh_w32(prev, next); continue; case SUH: next = reduce_duh_suh(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case SUH: next = reduce_mat_suh(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case SUH: next = reduce_opx_suh(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case SUH: next = reduce_opy_suh(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #269: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case SUH: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case DH0: case DH1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #270: // Runtime Memory // -------------- #271: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #272: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #273: State* hvm_get_state() { return &HVM; } #274: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #275: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #276: -- //./Type.hs// #277: module HVML.Extract where #278: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #279: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #280: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #281: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #282: DH0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh0) else extractCore book sub DH1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh1) else extractCore book sub #283: SUH -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Suh lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #284: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #285: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #286: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #287: -- Lifting Dups -- ------------ #288: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (Suh lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Suh lab tm0 tm1 liftDups (Duh lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Duh lab dp0 dp1 val k)) return bod #289: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #290: module HVML.Inject where #291: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #292: type InjectM a = StateT InjectState HVM a #293: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #294: emptyState :: InjectState emptyState = InjectState Map.empty [] #295: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #296: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #297: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #298: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #299: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #300: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #301: injectCore book (Suh lab tm0 tm1) loc = do suh <- lift $ allocNode 2 injectCore book tm0 (suh + 0) injectCore book tm1 (suh + 1) lift $ set loc (termNew _SUH_ lab suh) #302: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #303: injectCore book (Duh lab dh0 dh1 val bod) loc = do duh <- lift $ allocNode 3 lift $ set (duh + 0) (termNew _SUB_ 0 0) lift $ set (duh + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dh0 (termNew _DH0_ lab duh) $ Map.insert dh1 (termNew _DH1_ lab duh) (args s) } injectCore book val (duh + 2) injectCore book bod loc #304: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #305: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #306: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #307: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #308: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #309: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Suh lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Duh lab dp0 dp1 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Suh lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Duh lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Suh l x y -> Suh l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Duh l x y v b -> Duh l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do let debug = False term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term when debug $ do root <- got 0 root <- doExtractCore book root core <- doExtractCore book term putStrLn $ "---------------- CORE: " putStrLn $ coreToString core putStrLn $ "---------------- ROOT: " putStrLn $ coreToString root putStrLn $ "reduce " ++ termToString term val <- got (loc + 2) putStrLn $ "TERM: " ++ termToString term ++ " || VAL " ++ termToString val ++ " !!" case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) SUH -> cont host (reduceAppSuh term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vloc = termLoc val let vlab = termLab val let vtag = tagT (termTag val) isChain <- if vtag == DH0 || vtag == DH1 then do let vkey = termKey val vsub <- got vkey return $ termTag vsub == _SUB_ else do -- putStrLn "NOPES" return False if isChain && vlab == lab then do -- putStrLn $ "duhduh: " ++ show (tagT tag) ++ " " ++ show vtag cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) SUH -> cont host (reduceMatSuh term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) SUH -> cont host (reduceOpxSuh term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) SUH -> cont host (reduceOpySuh term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf SUH -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf DH0 -> do normalAtWith reduceAt book (loc + 2) return whnf DH1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Suh lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Duh lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Suh lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Duh lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Suh Word64 Core Core | Dup Word64 String String Core Core | Duh Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | DH0 | DH1 | VAR | APP | ERA | LAM | SUP | SUH | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_suh" reduceAppSuh :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_suh" reduceDupSuh :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_suh" reduceMatSuh :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_suh" reduceOpxSuh :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_suh" reduceOpySuh :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_duh_era" reduceDuhEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_duh_lam" reduceDuhLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_duh_sup" reduceDuhSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_duh_ctr" reduceDuhCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_duh_w32" reduceDuhW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_duh_suh" reduceDuhSuh :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c reduce_duh_duh" reduceDuhDuh :: Term -> Term -> IO Term #175: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #176: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #177: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #178: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #180: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #181: -- Constants -- --------- #182: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = DH0 tagT 0x03 = DH1 tagT 0x04 = VAR tagT 0x05 = SUB tagT 0x06 = REF tagT 0x07 = LET tagT 0x08 = APP tagT 0x09 = MAT tagT 0x0A = OPX tagT 0x0B = OPY tagT 0x0C = ERA tagT 0x0D = LAM tagT 0x0E = SUP tagT 0x0F = SUH tagT 0x10 = CTR tagT 0x11 = W32 tagT tag = error $ "unknown tag: " ++ show tag #183: _DP0_, _DP1_, _VAR_, _SUB_, _DH0_, _DH1_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _SUH_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _DH0_ = 0x02 _DH1_ = 0x03 _VAR_ = 0x04 _SUB_ = 0x05 _REF_ = 0x06 _LET_ = 0x07 _APP_ = 0x08 _MAT_ = 0x09 _OPX_ = 0x0A _OPY_ = 0x0B _ERA_ = 0x0C _LAM_ = 0x0D _SUP_ = 0x0E _SUH_ = 0x0F _CTR_ = 0x10 _W32_ = 0x11 #184: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #185: //./Type.hs// #186: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #187: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #188: typedef _Atomic(Term) ATerm; #189: // Runtime Types // ------------- #190: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #191: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #192: // Constants // --------- #193: #define DP0 0x00 #define DP1 0x01 #define DH0 0x02 #define DH1 0x03 #define VAR 0x04 #define SUB 0x05 #define REF 0x06 #define LET 0x07 #define APP 0x08 #define MAT 0x09 #define OPX 0x0A #define OPY 0x0B #define ERA 0x0C #define LAM 0x0D #define SUP 0x0E #define SUH 0x0F #define CTR 0x10 #define W32 0x11 #194: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #195: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #196: #define VOID 0x00000000000000 #197: // Heap // ---- #198: Loc get_len() { return *HVM.size; } #199: u64 get_itr() { return *HVM.itrs; } #200: void set_len(Loc value) { *HVM.size = value; } #201: void set_itr(Loc value) { *HVM.itrs = value; } #202: // Terms // ------ #203: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #204: Tag term_tag(Term x) { return x & 0xFF; } #205: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #206: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #207: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case DH0: return term_loc(term) + 0; case DH1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #208: // u12v2 // ----- #209: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #210: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #211: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #212: // Atomics // ------- #213: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #214: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #215: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #216: Term take(Loc loc) { return swap(loc, VOID); } #217: // Allocation // ---------- #218: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #219: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #220: // Stringification // --------------- #221: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case DH0: printf("DH0"); break; case DH1: printf("DH1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case SUH: printf("SUH"); break; default : printf("???"); break; } } #222: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #223: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #224: // Evaluation // ---------- #225: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #226: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #227: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #228: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #229: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #230: // ,----------------,---------------, // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : /_\y a/#\ : /_\y /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // :----------------|---------------| // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : x /_\ a/#\ : x /_\ /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // '----------------'---------------' //A: //- in = 0 //- up = 0 //- put = 1 = !in //- mof = 0 = up //- ret = 0 = in #231: //B: //- in = 1 //- up = 0 //- put = 0 = !in //- mof = 0 = up //- ret = 1 = in #232: //C: //- in = 0 //- up = 1 //- put = 1 = !in //- mof = 1 = up //- ret = 0 = in #233: //D: //- in = 1 //- up = 1 //- put = 0 = !in //- mof = 1 = up //- ret = 1 = in #234: // %L{y0 y1} = v // %L{x0 x1} = y0 // --------------- DUH_DUH // %L{x0 x1} = v // %L{y0 y1} = y0 // x1 <- y0 Term reduce_duh_duh(Term bot, Term top) { Loc bot_loc = term_loc(bot); Lab bot_lab = term_lab(bot); Loc top_loc = term_loc(top); Loc top_lab = term_lab(top); Term bot_val = got(bot_loc + 2); Term top_val = got(top_loc + 2); Tag in_A = term_tag(bot) == DH0 ? 0 : 1; Tag in_B = 1 - in_A; Tag up_A = term_tag(bot_val) == DH0 ? 0 : 1; Tag up_B = 1 - up_A; Loc new_duh = alloc_node(3); set(new_duh + 0, term_new(SUB, 0, 0)); set(new_duh + 1, term_new(SUB, 0, 0)); set(new_duh + 2, top_val); set(top_loc + up_A, term_new(SUB, 0, 0)); set(top_loc + 2 , term_new(DH0+in_B, bot_lab, new_duh)); set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); return term_new(DH0+in_A, bot_lab, new_duh); } #235: // (%L{a b} c) // ----------------- APP-SUP // ! %L{x0 x1} = c // %L{(a x0) (b x1)} Term reduce_app_suh(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DH0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUH, sup_lab, su0); } #236: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #237: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #238: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #239: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #240: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #241: // ! &L{x y} = %R{a b} // ------------------- DUP-SUH // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } #242: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #243: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #244: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #245: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #246: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #247: // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUH // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_suh(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DH0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DH1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUH, sup_lab, sup0); } #248: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #249: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #250: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #251: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #252: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #253: // <op(%L{x0 x1} y) // ------------------------- OPX-SUH // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_suh(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DH0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUH, sup_lab, su0); } #254: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #255: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #256: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #257: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #258: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #259: // >op(a %L{x y}) // --------------------- OPY-SUH // %L{>op(a x) >op(a y)} Term reduce_opy_suh(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUH, sup_lab, su0); } #260: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #261: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #262: // ! %L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_duh_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #263: // ! %L{r s} = λx(f) // ----------------- DUP-LAM // ! %L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- %L{x0 x1} Term reduce_duh_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DH0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DH1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUH, dup_lab, su0)); return got(dup_loc + dup_num); } #264: // ! %L{x y} = &R{a b} // ------------------- DUP-SUP // x <- &R{a0 b0} // y <- &R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } #265: // ! %L{x y} = %R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- %R{a0 b0} // y <- %R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } } #266: // ! %L{x y} = #{a b c ...} // ------------------------ DUH-CTR // ! %L{a0 a1} = a // ! %L{b0 b1} = b // ! %L{c0 c1} = c // ... // %L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_duh_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DH0, dup_lab, du0)); set(ctr1 + i, term_new(DH1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #267: // ! %L{x y} = 123 // --------------- DUH-W32 // x <- 123 // y <- 123 Term reduce_duh_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #268: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case DH0: case DH1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { Term prev = next; next = got(loc + 2); Tag ntag = term_tag(next); Lab nlab = term_lab(next); Loc nloc = term_loc(next); if ((ntag == DH0 || ntag == DH1) && lab == nlab) { Loc nkey = term_key(next); Term nsub = got(nkey); if (term_tag(nsub) == SUB) { next = reduce_duh_duh(prev, next); continue; } } HVM.sbuf[(*spos)++] = prev; continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case SUH: next = reduce_app_suh(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case SUH: next = reduce_dup_suh(prev, next); continue; default: break; } break; } case DH0: case DH1: { switch (tag) { case ERA: next = reduce_duh_era(prev, next); continue; case LAM: next = reduce_duh_lam(prev, next); continue; case SUP: next = reduce_duh_sup(prev, next); continue; case CTR: next = reduce_duh_ctr(prev, next); continue; case W32: next = reduce_duh_w32(prev, next); continue; case SUH: next = reduce_duh_suh(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case SUH: next = reduce_mat_suh(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case SUH: next = reduce_opx_suh(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case SUH: next = reduce_opy_suh(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #269: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case SUH: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case DH0: case DH1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #270: // Runtime Memory // -------------- #271: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #272: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #273: State* hvm_get_state() { return &HVM; } #274: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #275: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #276: -- //./Type.hs// #277: module HVML.Extract where #278: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #279: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #280: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #281: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #282: DH0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh0) else extractCore book sub DH1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh1) else extractCore book sub #283: SUH -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Suh lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #284: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #285: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #286: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #287: -- Lifting Dups -- ------------ #288: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (Suh lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Suh lab tm0 tm1 liftDups (Duh lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Duh lab dp0 dp1 val k)) return bod #289: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #290: module HVML.Inject where #291: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #292: type InjectM a = StateT InjectState HVM a #293: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #294: emptyState :: InjectState emptyState = InjectState Map.empty [] #295: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #296: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #297: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #298: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #299: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #300: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #301: injectCore book (Suh lab tm0 tm1) loc = do suh <- lift $ allocNode 2 injectCore book tm0 (suh + 0) injectCore book tm1 (suh + 1) lift $ set loc (termNew _SUH_ lab suh) #302: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #303: injectCore book (Duh lab dh0 dh1 val bod) loc = do duh <- lift $ allocNode 3 lift $ set (duh + 0) (termNew _SUB_ 0 0) lift $ set (duh + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dh0 (termNew _DH0_ lab duh) $ Map.insert dh1 (termNew _DH1_ lab duh) (args s) } injectCore book val (duh + 2) injectCore book bod loc #304: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #305: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #306: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #307: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #308: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #309: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

49c55c59293dbf482fa4d192064c6bfb0cd13d53

unordered sups: cleaner oportunistic swap approach unordered sups and dups will now be identical to normal sups and dups, rather than dups storing only one argument. to solve the quadratic issue, we just perform oportunistic swaps: whenever we enter the aux port of an unordered dup node that is connected to another unordered dup, we swap both nodes. this will give "higher priority" to nodes we accessed recently. this ensures that, in cases where there is an accumulation of redundant dup nodes, these will be harmless, since we'll push the relevant dup nodes closer to the duplicated values, and the redundant ones will not be accessed. NOTE: the code is currently completely duplicated for the implementation of dups/sups and unordered sups/dups. I'll clean up later

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod coreToString (USp lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (UDp lab dp0 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ USp lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do -- parsing 'dup' consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ UDp lab dp0 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era USp l x y -> USp l (decorateFnIds fids x) (decorateFnIds fids y) UDp l x v b -> UDp l x (decorateFnIds fids v) (decorateFnIds fids b) #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do root <- got 0 root <- doExtractCore book root putStrLn $ "---------------- ROOT:" putStrLn $ coreToString root term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) USP -> cont host (reduceAppUsp term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) USP -> cont host (reduceMatUsp term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) USP -> cont host (reduceOpxUsp term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) USP -> cont host (reduceOpyUsp term val) _ -> set (loc + 1) val >> return term UDP -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceUdpEra term val) LAM -> cont host (reduceUdpLam term val) SUP -> cont host (reduceUdpSup term val) CTR -> cont host (reduceUdpCtr term val) W32 -> cont host (reduceUdpW32 term val) USP -> cont host (reduceUdpUsp term val) _ -> set (loc + 1) val >> return term else do set host sub reduceAt book host VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf UDP -> do normalAtWith reduceAt book (loc + 1) return whnf USP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core | USp Word64 Core Core | UDp Word64 String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | UDP | APP | ERA | LAM | SUP | USP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_usp" reduceAppUsp :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_usp" reduceDupUsp :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_usp" reduceMatUsp :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_usp" reduceOpxUsp :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_usp" reduceOpyUsp :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_udp_era" reduceUdpEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_udp_lam" reduceUdpLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_udp_sup" reduceUdpSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_udp_ctr" reduceUdpCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_udp_w32" reduceUdpW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_udp_usp" reduceUdpUsp :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #175: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #176: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #177: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #178: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #180: -- Constants -- --------- #181: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = UDP tagT 0x03 = VAR tagT 0x04 = SUB tagT 0x05 = REF tagT 0x06 = LET tagT 0x07 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = USP tagT 0x0F = CTR tagT 0x10 = W32 tagT tag = error $ "unknown tag: " ++ show tag #182: _DP0_, _DP1_, _VAR_, _SUB_, _UDP_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _USP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _UDP_ = 0x02 _VAR_ = 0x03 _SUB_ = 0x04 _REF_ = 0x05 _LET_ = 0x06 _APP_ = 0x07 _MAT_ = 0x08 _OPX_ = 0x09 _OPY_ = 0x0A _ERA_ = 0x0B _LAM_ = 0x0C _SUP_ = 0x0D _USP_ = 0x0E _CTR_ = 0x0F _W32_ = 0x10 #183: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #184: //./Type.hs// #185: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #186: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #187: typedef _Atomic(Term) ATerm; #188: // Runtime Types // ------------- #189: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #190: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #191: // Constants // --------- #192: #define DP0 0x00 #define DP1 0x01 #define UDP 0x02 #define VAR 0x03 #define SUB 0x04 #define REF 0x05 #define LET 0x06 #define APP 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define USP 0x0E #define CTR 0x0F #define W32 0x10 #193: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #194: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #195: #define VOID 0x00000000000000 #196: // Heap // ---- #197: Loc get_len() { return *HVM.size; } #198: u64 get_itr() { return *HVM.itrs; } #199: void set_len(Loc value) { *HVM.size = value; } #200: void set_itr(Loc value) { *HVM.itrs = value; } #201: // Terms // ------ #202: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #203: Tag term_tag(Term x) { return x & 0xFF; } #204: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #205: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #206: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case UDP: return term_loc(term) + 0; case VAR: return term_loc(term) + 0; default: return 0; } } #207: // u12v2 // ----- #208: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #209: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #210: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #211: // Atomics // ------- #212: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #213: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #214: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #215: Term take(Loc loc) { return swap(loc, VOID); } #216: // Allocation // ---------- #217: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #218: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #219: // Stringification // --------------- #220: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case UDP: printf("UDP"); break; case USP: printf("USP"); break; default : printf("???"); break; } } #221: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #222: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #223: // Evaluation // ---------- #224: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #225: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #226: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #227: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #228: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #229: // (%L{a b} c) // --------------- APP-USP // ! %L{x} = c // %L{(a x) (b x)} Term reduce_app_usp(Term app, Term usp) { inc_itr(); Loc app_loc = term_loc(app); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term arg = got(app_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); Term cop; if (term_tag(arg) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, arg); cop = term_new(UDP, usp_lab, du0); } else { cop = arg; } set(ap0 + 0, tm0); set(ap0 + 1, cop); set(ap1 + 0, tm1); set(ap1 + 1, cop); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(USP, usp_lab, su0); } #230: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #231: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #232: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #233: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #234: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #235: // ! &L{x y} = %R{a b} // ------------------- DUP-USP // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_usp(Term dup, Term usp) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc us0 = alloc_node(2); Loc us1 = alloc_node(2); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(us0 + 0, term_new(DP0, dup_lab, du0)); set(us0 + 1, term_new(DP0, dup_lab, du1)); set(us1 + 0, term_new(DP1, dup_lab, du0)); set(us1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(USP, usp_lab, us0)); set(dup_loc + 1, term_new(USP, usp_lab, us1)); return got(dup_loc + dup_num); } #236: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #237: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #238: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #239: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #240: // TODO: treat SUP label // ~ &{x y} {K0 K1 K2 ...} // ----------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // &{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #241: // MAT_USP: TODO // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-USP // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_usp(Term mat, Term usp) { inc_itr(); Loc mat_loc = term_loc(mat); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Lab mat_len = term_lab(mat); Loc usp0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Term cse = got(mat_loc + 1 + i); Term cop; if (term_tag(cse) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(mat_loc + 1 + i)); cop = term_new(UDP, usp_lab, du0); } else { cop = cse; } set(mat0 + 1 + i, cop); set(mat1 + 1 + i, cop); } set(usp0 + 0, term_new(MAT, mat_len, mat0)); set(usp0 + 1, term_new(MAT, mat_len, mat1)); return term_new(USP, usp_lab, usp0); } #242: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #243: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #244: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #245: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #246: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #247: // <op(%L{x0 x1} y) // ------------------------- OPX-USP // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_usp(Term opx, Term usp) { //printf("opx-usp\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmy = got(opx_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); Term cop; if (term_tag(nmy) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, nmy); cop = term_new(UDP, usp_lab, du0); } else { cop = nmy; } set(op0 + 0, tm0); set(op0 + 1, cop); set(op1 + 0, tm1); set(op1 + 1, cop); set(us0 + 0, term_new(OPX, term_lab(opx), op0)); set(us0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(USP, usp_lab, us0); } #248: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #249: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #250: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #251: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #252: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #253: // >op(a %L{x y}) // --------------------- OPY-USP // %L{>op(a x) >op(a y)} Term reduce_opy_usp(Term opy, Term usp) { inc_itr(); Loc opy_loc = term_loc(opy); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmx = got(opy_loc + 0); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(us0 + 0, term_new(OPY, term_lab(opy), op0)); set(us0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(USP, usp_lab, us0); } #254: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #255: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #256: // ! %L{x} = * // ----------- UDP-ERA // x <- * Term reduce_udp_era(Term udp, Term era) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, era); return era; } #257: // ! &L{F} = λx(f) // ----------------- UDP-LAM // ! &L{G} = f // F <- λx0(G) // F <- λx1(G) // x <- &L{x0 x1} Term reduce_udp_lam(Term udp, Term lam) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); Term cop; if (term_tag(bod) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, bod); cop = term_new(UDP, udp_lab, du0); } else { cop = bod; } set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, cop); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, cop); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(udp_loc + 0, term_new(LAM, 0, lm0)); set(lam_loc + 0, term_new(USP, udp_lab, su0)); return got(udp_loc + 0); } #258: // TODO: UDP-SUP Term reduce_udp_sup(Term udp, Term sup) { printf("TODO:udp-sup\n"); exit(0); } #259: // ! %L{x} = %R{a b} // ------------------- UDP-USP // if L == R: // x <- b // a // else: // TODO Term reduce_udp_usp(Term udp, Term usp) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); if (udp_lab == usp_lab) { Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(udp_loc + 0, tm1); return tm0; } else { printf("TODO:udp-usp\n"); exit(0); } } #260: // ! %L{x} = #{a b c ...} // ---------------------- UDP-CTR // x <- #{ax bx cx ...} // ! %L{ax} = a // ! %L{bx} = b // ! %L{cx} = c // ... // #{ax bx cx ...} // NOTE: this must create two separate CTRs Term reduce_udp_ctr(Term udp, Term ctr) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ct0 = alloc_node(ctr_ari); Loc ct1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Term fld = got(ctr_loc + i); Term cop; if (term_tag(fld) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(ctr_loc + i)); cop = term_new(UDP, udp_lab, du0); } else { cop = fld; } set(ct0 + i, cop); set(ct1 + i, cop); } set(udp_loc + 0, term_new(CTR, ctr_lab, ct1)); return term_new(CTR, ctr_lab, ct0); } #261: // ! %L{x} = 123 // ------------- UDP-W32 // x <- 123 // 123 Term reduce_udp_w32(Term udp, Term w32) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, w32); return w32; } #262: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case UDP: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case USP: next = reduce_app_usp(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case USP: next = reduce_dup_usp(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case USP: next = reduce_mat_usp(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case USP: next = reduce_opx_usp(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case USP: next = reduce_opy_usp(prev, next); continue; default: break; } } case UDP: { switch (tag) { case ERA: next = reduce_udp_era(prev, next); continue; case LAM: next = reduce_udp_lam(prev, next); continue; case SUP: next = reduce_udp_sup(prev, next); continue; case CTR: next = reduce_udp_ctr(prev, next); continue; case W32: next = reduce_udp_w32(prev, next); continue; case USP: next = reduce_udp_usp(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #263: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #264: // Runtime Memory // -------------- #265: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #266: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #267: State* hvm_get_state() { return &HVM; } #268: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #269: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #270: -- //./Type.hs// #271: module HVML.Extract where #272: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #273: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #274: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #275: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #276: UDP -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) val <- lift $ got (loc + 1) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ UDp lab dp0 val0 (Var dp0) else extractCore book sub #277: USP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ USp lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #278: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #279: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #280: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #281: -- Lifting Dups -- ------------ #282: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (USp lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ USp lab tm0 tm1 liftDups (UDp lab dp val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (UDp lab dp val k)) return bod #283: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #284: module HVML.Inject where #285: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #286: type InjectM a = StateT InjectState HVM a #287: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #288: emptyState :: InjectState emptyState = InjectState Map.empty [] #289: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #290: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #291: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #292: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #293: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #294: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #295: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #296: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #297: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #298: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #299: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #300: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #301: injectCore book (USp lab tm0 tm1) loc = do usp <- lift $ allocNode 2 injectCore book tm0 (usp + 0) injectCore book tm1 (usp + 1) lift $ set loc (termNew _USP_ lab usp) #302: injectCore book (UDp lab dp0 val bod) loc = do udp <- lift $ allocNode 2 lift $ set (udp + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _UDP_ lab udp) (args s) } injectCore book val (udp + 1) injectCore book bod loc #303: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Suh lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Duh lab dp0 dp1 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Suh lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Duh lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Suh l x y -> Suh l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Duh l x y v b -> Duh l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do term <- got host -- root <- got 0 -- root <- doExtractCore book root -- core <- doExtractCore book term -- putStrLn $ "---------------- CORE: " -- putStrLn $ coreToString core -- putStrLn $ "---------------- ROOT: " -- putStrLn $ coreToString root -- putStrLn $ "reduce " ++ termToString term let tag = termTag term let lab = termLab term let loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) SUH -> cont host (reduceAppSuh term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) SUH -> cont host (reduceDupSuh term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vlab = termLab val let vtag = tagT (termTag val) if (vtag == DH0 || vtag == DH1) && vlab == lab then do cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DH1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) let vlab = termLab val let vtag = tagT (termTag val) if (vtag == DH0 || vtag == DH1) && vlab == lab then do cont host (reduceDuhDuh term val) else do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDuhEra term val) LAM -> cont host (reduceDuhLam term val) SUP -> cont host (reduceDuhSup term val) SUH -> cont host (reduceDuhSuh term val) CTR -> cont host (reduceDuhCtr term val) W32 -> cont host (reduceDuhW32 term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) SUH -> cont host (reduceMatSuh term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) SUH -> cont host (reduceOpxSuh term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) SUH -> cont host (reduceOpySuh term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf SUH -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf DH0 -> do normalAtWith reduceAt book (loc + 2) return whnf DH1 -> do normalAtWith reduceAt book (loc + 2) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Suh lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Duh lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Suh lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUH, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Duh lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DH0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DH1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Suh Word64 Core Core | Dup Word64 String String Core Core | Duh Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | DH0 | DH1 | VAR | APP | ERA | LAM | SUP | SUH | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_suh" reduceAppSuh :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_suh" reduceDupSuh :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_suh" reduceMatSuh :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_suh" reduceOpxSuh :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_suh" reduceOpySuh :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_duh_era" reduceDuhEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_duh_lam" reduceDuhLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_duh_sup" reduceDuhSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_duh_ctr" reduceDuhCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_duh_w32" reduceDuhW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_duh_suh" reduceDuhSuh :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c reduce_duh_duh" reduceDuhDuh :: Term -> Term -> IO Term #175: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #176: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #177: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #178: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #180: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #181: -- Constants -- --------- #182: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = DH0 tagT 0x03 = DH1 tagT 0x04 = VAR tagT 0x05 = SUB tagT 0x06 = REF tagT 0x07 = LET tagT 0x08 = APP tagT 0x09 = MAT tagT 0x0A = OPX tagT 0x0B = OPY tagT 0x0C = ERA tagT 0x0D = LAM tagT 0x0E = SUP tagT 0x0F = SUH tagT 0x10 = CTR tagT 0x11 = W32 tagT tag = error $ "unknown tag: " ++ show tag #183: _DP0_, _DP1_, _VAR_, _SUB_, _DH0_, _DH1_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _SUH_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _DH0_ = 0x02 _DH1_ = 0x03 _VAR_ = 0x04 _SUB_ = 0x05 _REF_ = 0x06 _LET_ = 0x07 _APP_ = 0x08 _MAT_ = 0x09 _OPX_ = 0x0A _OPY_ = 0x0B _ERA_ = 0x0C _LAM_ = 0x0D _SUP_ = 0x0E _SUH_ = 0x0F _CTR_ = 0x10 _W32_ = 0x11 #184: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #185: //./Type.hs// #186: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #187: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #188: typedef _Atomic(Term) ATerm; #189: // Runtime Types // ------------- #190: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #191: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #192: // Constants // --------- #193: #define DP0 0x00 #define DP1 0x01 #define DH0 0x02 #define DH1 0x03 #define VAR 0x04 #define SUB 0x05 #define REF 0x06 #define LET 0x07 #define APP 0x08 #define MAT 0x09 #define OPX 0x0A #define OPY 0x0B #define ERA 0x0C #define LAM 0x0D #define SUP 0x0E #define SUH 0x0F #define CTR 0x10 #define W32 0x11 #194: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #195: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #196: #define VOID 0x00000000000000 #197: // Heap // ---- #198: Loc get_len() { return *HVM.size; } #199: u64 get_itr() { return *HVM.itrs; } #200: void set_len(Loc value) { *HVM.size = value; } #201: void set_itr(Loc value) { *HVM.itrs = value; } #202: // Terms // ------ #203: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #204: Tag term_tag(Term x) { return x & 0xFF; } #205: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #206: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #207: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case DH0: return term_loc(term) + 0; case DH1: return term_loc(term) + 1; case VAR: return term_loc(term) + 0; default: return 0; } } #208: // u12v2 // ----- #209: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #210: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #211: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #212: // Atomics // ------- #213: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #214: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #215: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #216: Term take(Loc loc) { return swap(loc, VOID); } #217: // Allocation // ---------- #218: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #219: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #220: // Stringification // --------------- #221: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case DH0: printf("DH0"); break; case DH1: printf("DH1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case SUH: printf("SUH"); break; default : printf("???"); break; } } #222: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #223: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #224: // Evaluation // ---------- #225: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #226: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #227: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #228: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #229: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #230: // ,----------------,---------------, // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : /_\y a/#\ : /_\y /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // :----------------|---------------| // : v v : v v : // : | | : | | : // : /#\ /_\ : /#\ /_\ : // : | | | | : | | | | : // : x /_\ a/#\ : x /_\ /#\b : // : | | ↑| | : | | | |↑ : // : a b x y : a b x y : // : ↑ b : ↑ a : // '----------------'---------------' //A: //- in = 0 //- up = 0 //- put = 1 = !in //- mof = 0 = up //- ret = 0 = in #231: //B: //- in = 1 //- up = 0 //- put = 0 = !in //- mof = 0 = up //- ret = 1 = in #232: //C: //- in = 0 //- up = 1 //- put = 1 = !in //- mof = 1 = up //- ret = 0 = in #233: //D: //- in = 1 //- up = 1 //- put = 0 = !in //- mof = 1 = up //- ret = 1 = in #234: // %L{y0 y1} = v // %L{x0 x1} = y0 // --------------- DUH_DUH // %L{x0 x1} = v // %L{y0 y1} = y0 // x1 <- y0 Term reduce_duh_duh(Term bot, Term top) { Loc bot_loc = term_loc(bot); Lab bot_lab = term_lab(bot); Loc top_loc = term_loc(top); Loc top_lab = term_lab(top); Term bot_val = got(bot_loc + 2); Term top_val = got(top_loc + 2); Tag in_A = term_tag(bot) == DH0 ? 0 : 1; Tag in_B = 1 - in_A; Tag up_A = term_tag(bot_val) == DH0 ? 0 : 1; Tag up_B = 1 - up_A; Loc new_duh = alloc_node(3); set(new_duh + 0, term_new(SUB, 0, 0)); set(new_duh + 1, term_new(SUB, 0, 0)); set(new_duh + 2, top_val); set(top_loc + up_A, term_new(SUB, 0, 0)); set(top_loc + 2 , term_new(DH0+in_B, bot_lab, new_duh)); set(bot_loc + in_B, term_new(DH0+up_A, bot_lab, top_loc)); return term_new(DH0+in_A, bot_lab, new_duh); } #235: // (%L{a b} c) // ----------------- APP-SUP // ! %L{x0 x1} = c // %L{(a x0) (b x1)} Term reduce_app_suh(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DH0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUH, sup_lab, su0); } #236: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #237: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #238: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #239: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #240: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #241: // ! &L{x y} = %R{a b} // ------------------- DUP-SUH // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } #242: // ! &L{x y} = #{a b c ...} // ------------------------ DUP-CTR // ! &L{a0 a1} = a // ! &L{b0 b1} = b // ! &L{c0 c1} = c // ... // &L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, dup_lab, du0)); set(ctr1 + i, term_new(DP1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #243: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #244: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #245: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #246: // TODO: treat SUP label // ~ &L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUP // ! &L{k0a k0b} = K0 // ! &L{k1a k1b} = K1 // ! &L{k2a k2b} = K2 // ... // &L{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DP1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, sup_lab, sup0); } #247: // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-SUH // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_suh(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DH0, sup_lab, du0)); set(mat1 + 1 + i, term_new(DH1, sup_lab, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUH, sup_lab, sup0); } #248: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #249: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #250: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #251: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #252: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #253: // <op(%L{x0 x1} y) // ------------------------- OPX-SUH // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_suh(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DH0, sup_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DH1, sup_lab, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUH, sup_lab, su0); } #254: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #255: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #256: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #257: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #258: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #259: // >op(a %L{x y}) // --------------------- OPY-SUH // %L{>op(a x) >op(a y)} Term reduce_opy_suh(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUH, sup_lab, su0); } #260: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #261: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #262: // ! %L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_duh_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #263: // ! %L{r s} = λx(f) // ----------------- DUP-LAM // ! %L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- %L{x0 x1} Term reduce_duh_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DH0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DH1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUH, dup_lab, su0)); return got(dup_loc + dup_num); } #264: // ! %L{x y} = &R{a b} // ------------------- DUP-SUP // x <- &R{a0 b0} // y <- &R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } #265: // ! %L{x y} = %R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- %R{a0 b0} // y <- %R{a1 b1} // ! %L{a0 a1} = a // ! %L{b0 b1} = b Term reduce_duh_suh(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DH0, dup_lab, du0)); set(su0 + 1, term_new(DH0, dup_lab, du1)); set(su1 + 0, term_new(DH1, dup_lab, du0)); set(su1 + 1, term_new(DH1, dup_lab, du1)); set(dup_loc + 0, term_new(SUH, sup_lab, su0)); set(dup_loc + 1, term_new(SUH, sup_lab, su1)); return got(dup_loc + dup_num); } } #266: // ! %L{x y} = #{a b c ...} // ------------------------ DUH-CTR // ! %L{a0 a1} = a // ! %L{b0 b1} = b // ! %L{c0 c1} = c // ... // %L{#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_duh_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DH0, dup_lab, du0)); set(ctr1 + i, term_new(DH1, dup_lab, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #267: // ! %L{x y} = 123 // --------------- DUH-W32 // x <- 123 // y <- 123 Term reduce_duh_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DH0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #268: Term reduce(Term term) { if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("reduce "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case DH0: case DH1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { Term prev = next; next = got(loc + 2); Tag ntag = term_tag(next); Lab nlab = term_lab(next); Loc nloc = term_loc(next); if ((ntag == DH0 || ntag == DH1) && lab == nlab) { next = reduce_duh_duh(prev, next); continue; } HVM.sbuf[(*spos)++] = prev; continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case SUH: next = reduce_app_suh(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case SUH: next = reduce_dup_suh(prev, next); continue; default: break; } break; } case DH0: case DH1: { switch (tag) { case ERA: next = reduce_duh_era(prev, next); continue; case LAM: next = reduce_duh_lam(prev, next); continue; case SUP: next = reduce_duh_sup(prev, next); continue; case CTR: next = reduce_duh_ctr(prev, next); continue; case W32: next = reduce_duh_w32(prev, next); continue; case SUH: next = reduce_duh_suh(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case SUH: next = reduce_mat_suh(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case SUH: next = reduce_opx_suh(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case SUH: next = reduce_opy_suh(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #269: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case SUH: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case DH0: case DH1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #270: // Runtime Memory // -------------- #271: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #272: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #273: State* hvm_get_state() { return &HVM; } #274: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #275: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #276: -- //./Type.hs// #277: module HVML.Extract where #278: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #279: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #280: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #281: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #282: DH0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh0) else extractCore book sub DH1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dh0 <- genName (loc + 0) dh1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Duh lab dh0 dh1 val0 (Var dh1) else extractCore book sub #283: SUH -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Suh lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #284: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #285: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #286: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #287: -- Lifting Dups -- ------------ #288: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (Suh lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Suh lab tm0 tm1 liftDups (Duh lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Duh lab dp0 dp1 val k)) return bod #289: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #290: module HVML.Inject where #291: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #292: type InjectM a = StateT InjectState HVM a #293: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #294: emptyState :: InjectState emptyState = InjectState Map.empty [] #295: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #296: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #297: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #298: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #299: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #300: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #301: injectCore book (Suh lab tm0 tm1) loc = do suh <- lift $ allocNode 2 injectCore book tm0 (suh + 0) injectCore book tm1 (suh + 1) lift $ set loc (termNew _SUH_ lab suh) #302: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #303: injectCore book (Duh lab dh0 dh1 val bod) loc = do duh <- lift $ allocNode 3 lift $ set (duh + 0) (termNew _SUB_ 0 0) lift $ set (duh + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dh0 (termNew _DH0_ lab duh) $ Map.insert dh1 (termNew _DH1_ lab duh) (args s) } injectCore book val (duh + 2) injectCore book bod loc #304: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #305: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #306: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #307: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #308: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #309: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

f51372adb318678476f8804403813b6c298b4fdd

fix unordered superposition implementation 1. the lam rule actually needs to propagate unordered superpositions 2. we now apply the udup-contraction optimization, resulting in the quadratic speedup

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod coreToString (USp lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (UDp lab dp0 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ USp lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do -- parsing 'dup' consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ UDp lab dp0 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era USp l x y -> USp l (decorateFnIds fids x) (decorateFnIds fids y) UDp l x v b -> UDp l x (decorateFnIds fids v) (decorateFnIds fids b) #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do root <- got 0 root <- doExtractCore book root putStrLn $ "---------------- ROOT:" putStrLn $ coreToString root term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) USP -> cont host (reduceAppUsp term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) USP -> cont host (reduceMatUsp term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) USP -> cont host (reduceOpxUsp term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) USP -> cont host (reduceOpyUsp term val) _ -> set (loc + 1) val >> return term UDP -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceUdpEra term val) LAM -> cont host (reduceUdpLam term val) SUP -> cont host (reduceUdpSup term val) CTR -> cont host (reduceUdpCtr term val) W32 -> cont host (reduceUdpW32 term val) USP -> cont host (reduceUdpUsp term val) _ -> set (loc + 1) val >> return term else do set host sub reduceAt book host VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf UDP -> do normalAtWith reduceAt book (loc + 1) return whnf USP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core | USp Word64 Core Core | UDp Word64 String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | UDP | APP | ERA | LAM | SUP | USP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_usp" reduceAppUsp :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_usp" reduceDupUsp :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_usp" reduceMatUsp :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_usp" reduceOpxUsp :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_usp" reduceOpyUsp :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_udp_era" reduceUdpEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_udp_lam" reduceUdpLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_udp_sup" reduceUdpSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_udp_ctr" reduceUdpCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_udp_w32" reduceUdpW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_udp_usp" reduceUdpUsp :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #175: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #176: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #177: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #178: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #180: -- Constants -- --------- #181: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = UDP tagT 0x03 = VAR tagT 0x04 = SUB tagT 0x05 = REF tagT 0x06 = LET tagT 0x07 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = USP tagT 0x0F = CTR tagT 0x10 = W32 tagT tag = error $ "unknown tag: " ++ show tag #182: _DP0_, _DP1_, _VAR_, _SUB_, _UDP_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _USP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _UDP_ = 0x02 _VAR_ = 0x03 _SUB_ = 0x04 _REF_ = 0x05 _LET_ = 0x06 _APP_ = 0x07 _MAT_ = 0x08 _OPX_ = 0x09 _OPY_ = 0x0A _ERA_ = 0x0B _LAM_ = 0x0C _SUP_ = 0x0D _USP_ = 0x0E _CTR_ = 0x0F _W32_ = 0x10 #183: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #184: //./Type.hs// #185: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #186: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #187: typedef _Atomic(Term) ATerm; #188: // Runtime Types // ------------- #189: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #190: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #191: // Constants // --------- #192: #define DP0 0x00 #define DP1 0x01 #define UDP 0x02 #define VAR 0x03 #define SUB 0x04 #define REF 0x05 #define LET 0x06 #define APP 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define USP 0x0E #define CTR 0x0F #define W32 0x10 #193: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #194: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #195: #define VOID 0x00000000000000 #196: // Heap // ---- #197: Loc get_len() { return *HVM.size; } #198: u64 get_itr() { return *HVM.itrs; } #199: void set_len(Loc value) { *HVM.size = value; } #200: void set_itr(Loc value) { *HVM.itrs = value; } #201: // Terms // ------ #202: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #203: Tag term_tag(Term x) { return x & 0xFF; } #204: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #205: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #206: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case UDP: return term_loc(term) + 0; case VAR: return term_loc(term) + 0; default: return 0; } } #207: // u12v2 // ----- #208: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #209: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #210: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #211: // Atomics // ------- #212: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #213: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #214: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #215: Term take(Loc loc) { return swap(loc, VOID); } #216: // Allocation // ---------- #217: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #218: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #219: // Stringification // --------------- #220: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case UDP: printf("UDP"); break; case USP: printf("USP"); break; default : printf("???"); break; } } #221: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #222: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #223: // Evaluation // ---------- #224: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #225: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #226: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #227: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #228: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #229: // (%L{a b} c) // --------------- APP-USP // ! %L{x} = c // %L{(a x) (b x)} Term reduce_app_usp(Term app, Term usp) { inc_itr(); Loc app_loc = term_loc(app); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term arg = got(app_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc du0 = alloc_node(2); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); if (term_tag(arg) == UDP) { printf("SHORTEN\n"); } set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(UDP, usp_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(UDP, usp_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(USP, usp_lab, su0); } #230: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #231: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #232: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #233: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #234: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #235: // ! &L{x y} = %R{a b} // ------------------- DUP-USP // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_usp(Term dup, Term usp) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc us0 = alloc_node(2); Loc us1 = alloc_node(2); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(us0 + 0, term_new(DP0, dup_lab, du0)); set(us0 + 1, term_new(DP0, dup_lab, du1)); set(us1 + 0, term_new(DP1, dup_lab, du0)); set(us1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(USP, usp_lab, us0)); set(dup_loc + 1, term_new(USP, usp_lab, us1)); return got(dup_loc + dup_num); } #236: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #237: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #238: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #239: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #240: // TODO: treat SUP label // ~ &{x y} {K0 K1 K2 ...} // ----------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // &{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #241: // MAT_USP: TODO // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-USP // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_usp(Term mat, Term usp) { inc_itr(); Loc mat_loc = term_loc(mat); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Lab mat_len = term_lab(mat); Loc usp0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(mat_loc + 1 + i)); if (term_tag(got(mat_loc + 1 + i)) == UDP) { printf("SHORTEN\n"); } set(mat0 + 1 + i, term_new(UDP, usp_lab, du0)); set(mat1 + 1 + i, term_new(UDP, usp_lab, du0)); } set(usp0 + 0, term_new(MAT, mat_len, mat0)); set(usp0 + 1, term_new(MAT, mat_len, mat1)); return term_new(USP, usp_lab, usp0); } #242: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #243: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #244: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #245: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #246: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #247: // <op(%L{x0 x1} y) // ------------------------- OPX-USP // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_usp(Term opx, Term usp) { //printf("opx-usp\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmy = got(opx_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc du0 = alloc_node(2); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(UDP, usp_lab, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(UDP, usp_lab, du0)); set(us0 + 0, term_new(OPX, term_lab(opx), op0)); set(us0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(USP, usp_lab, us0); } #248: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #249: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #250: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #251: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #252: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #253: // >op(a %L{x y}) // --------------------- OPY-USP // %L{>op(a x) >op(a y)} Term reduce_opy_usp(Term opy, Term usp) { inc_itr(); Loc opy_loc = term_loc(opy); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmx = got(opy_loc + 0); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(us0 + 0, term_new(OPY, term_lab(opy), op0)); set(us0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(USP, usp_lab, us0); } #254: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #255: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #256: // ! %L{x} = * // ----------- UDP-ERA // x <- * Term reduce_udp_era(Term udp, Term era) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, era); return era; } #257: // ! &L{F} = λx(f) // ---------------- UDP-LAM // F <- λx(f) Term reduce_udp_lam(Term udp, Term lam) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, lam); return lam; } #258: // TODO: UDP-SUP Term reduce_udp_sup(Term udp, Term sup) { printf("TODO:udp-sup\n"); exit(0); } #259: // ! %L{x} = %R{a b} // ------------------- UDP-USP // if L == R: // x <- b // a // else: // TODO Term reduce_udp_usp(Term udp, Term usp) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); if (udp_lab == usp_lab) { Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(udp_loc + 0, tm1); return tm0; } else { printf("TODO:udp-usp\n"); exit(0); } } #260: // ! %L{x} = #{a b c ...} // ---------------------- UDP-CTR // x <- #{ax bx cx ...} // ! %L{ax} = a // ! %L{bx} = b // ! %L{cx} = c // ... // #{ax bx cx ...} // NOTE: this must create two separate CTRs Term reduce_udp_ctr(Term udp, Term ctr) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ct0 = alloc_node(ctr_ari); Loc ct1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(ctr_loc + i)); set(ct0 + i, term_new(UDP, udp_lab, du0)); set(ct1 + i, term_new(UDP, udp_lab, du0)); } set(udp_loc + 0, term_new(CTR, ctr_lab, ct1)); return term_new(CTR, ctr_lab, ct0); } #261: // ! %L{x} = 123 // ------------- UDP-W32 // x <- 123 // 123 Term reduce_udp_w32(Term udp, Term w32) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, w32); return w32; } #262: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case UDP: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case USP: next = reduce_app_usp(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case USP: next = reduce_dup_usp(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case USP: next = reduce_mat_usp(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case USP: next = reduce_opx_usp(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case USP: next = reduce_opy_usp(prev, next); continue; default: break; } } case UDP: { switch (tag) { case ERA: next = reduce_udp_era(prev, next); continue; case LAM: next = reduce_udp_lam(prev, next); continue; case SUP: next = reduce_udp_sup(prev, next); continue; case CTR: next = reduce_udp_ctr(prev, next); continue; case W32: next = reduce_udp_w32(prev, next); continue; case USP: next = reduce_udp_usp(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #263: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #264: // Runtime Memory // -------------- #265: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #266: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #267: State* hvm_get_state() { return &HVM; } #268: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #269: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #270: -- //./Type.hs// #271: module HVML.Extract where #272: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #273: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #274: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #275: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #276: UDP -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) val <- lift $ got (loc + 1) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ UDp lab dp0 val0 (Var dp0) else extractCore book sub #277: USP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ USp lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #278: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #279: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #280: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #281: -- Lifting Dups -- ------------ #282: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (USp lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ USp lab tm0 tm1 liftDups (UDp lab dp val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (UDp lab dp val k)) return bod #283: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #284: module HVML.Inject where #285: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #286: type InjectM a = StateT InjectState HVM a #287: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #288: emptyState :: InjectState emptyState = InjectState Map.empty [] #289: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #290: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #291: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #292: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #293: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #294: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #295: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #296: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #297: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #298: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #299: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #300: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #301: injectCore book (USp lab tm0 tm1) loc = do usp <- lift $ allocNode 2 injectCore book tm0 (usp + 0) injectCore book tm1 (usp + 1) lift $ set loc (termNew _USP_ lab usp) #302: injectCore book (UDp lab dp0 val bod) loc = do udp <- lift $ allocNode 2 lift $ set (udp + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _UDP_ lab udp) (args s) } injectCore book val (udp + 1) injectCore book bod loc #303: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

./Show.hs #1: -- //./Type.hs// -- //./Inject.hs// #2: module HVML.Show where #3: import Control.Monad.State import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "(~match " ++ coreToString val ++ " {" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "})" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ " " ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod coreToString (USp lab tm0 tm1) = "%" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (UDp lab dp0 val bod) = "! %" ++ show lab ++ "{" ++ dp0 ++ "} = " ++ coreToString val ++ "\n" ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '%' -> do consume "%" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ USp lab tm0 tm1 '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do -- parsing 'dup' consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '%' -> do consume "%" lab <- read <$> many1 digit consume "{" dp0 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ UDp lab dp0 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era USp l x y -> USp l (decorateFnIds fids x) (decorateFnIds fids y) UDp l x v b -> UDp l x (decorateFnIds fids v) (decorateFnIds fids b) #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when, forM) import Data.Word import HVML.Extract import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: reduceAt :: Book -> Loc -> HVM Term reduceAt book host = do root <- got 0 root <- doExtractCore book root putStrLn $ "---------------- ROOT:" putStrLn $ coreToString root term <- got host let tag = termTag term let lab = termLab term let loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) cont host (reduceLet term val) STRI -> do val <- reduceAt book (loc + 1) cont host (reduceLet term val) PARA -> do error "TODO" APP -> do fun <- reduceAt book (loc + 0) case tagT (termTag fun) of ERA -> cont host (reduceAppEra term fun) LAM -> cont host (reduceAppLam term fun) SUP -> cont host (reduceAppSup term fun) CTR -> cont host (reduceAppCtr term fun) W32 -> cont host (reduceAppW32 term fun) USP -> cont host (reduceAppUsp term fun) _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 2) case tagT (termTag val) of ERA -> cont host (reduceDupEra term val) LAM -> cont host (reduceDupLam term val) SUP -> cont host (reduceDupSup term val) CTR -> cont host (reduceDupCtr term val) W32 -> cont host (reduceDupW32 term val) USP -> cont host (reduceDupUsp term val) _ -> set (loc + 2) val >> return term else do set host sub reduceAt book host MAT -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceMatEra term val) LAM -> cont host (reduceMatLam term val) SUP -> cont host (reduceMatSup term val) CTR -> cont host (reduceMatCtr term val) W32 -> cont host (reduceMatW32 term val) USP -> cont host (reduceMatUsp term val) _ -> set (loc + 0) val >> return term OPX -> do val <- reduceAt book (loc + 0) case tagT (termTag val) of ERA -> cont host (reduceOpxEra term val) LAM -> cont host (reduceOpxLam term val) SUP -> cont host (reduceOpxSup term val) CTR -> cont host (reduceOpxCtr term val) W32 -> cont host (reduceOpxW32 term val) USP -> cont host (reduceOpxUsp term val) _ -> set (loc + 0) val >> return term OPY -> do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceOpyEra term val) LAM -> cont host (reduceOpyLam term val) SUP -> cont host (reduceOpySup term val) CTR -> cont host (reduceOpyCtr term val) W32 -> cont host (reduceOpyW32 term val) USP -> cont host (reduceOpyUsp term val) _ -> set (loc + 1) val >> return term UDP -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- reduceAt book (loc + 1) case tagT (termTag val) of ERA -> cont host (reduceUdpEra term val) LAM -> cont host (reduceUdpLam term val) SUP -> cont host (reduceUdpSup term val) CTR -> cont host (reduceUdpCtr term val) W32 -> cont host (reduceUdpW32 term val) USP -> cont host (reduceUdpUsp term val) _ -> set (loc + 1) val >> return term else do set host sub reduceAt book host VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return term else do set host sub reduceAt book host REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] doInjectCoreAt book core host $ zip nams args reduceAt book host Nothing -> return term otherwise -> do return term where cont host action = do ret <- action set host ret reduceAt book host #53: normalAtWith :: (Book -> Term -> HVM Term) -> Book -> Loc -> HVM Term normalAtWith reduceAt book host = do whnf <- reduceAt book host let tag = termTag whnf let lab = termLab whnf let loc = termLoc whnf case tagT tag of APP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf LAM -> do normalAtWith reduceAt book (loc + 1) return whnf SUP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf DP0 -> do normalAtWith reduceAt book (loc + 2) return whnf DP1 -> do normalAtWith reduceAt book (loc + 2) return whnf UDP -> do normalAtWith reduceAt book (loc + 1) return whnf USP -> do normalAtWith reduceAt book (loc + 0) normalAtWith reduceAt book (loc + 1) return whnf CTR -> do let ari = u12v2Y lab let ars = (if ari == 0 then [] else [0 .. ari - 1]) :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf MAT -> do let ari = lab let ars = [0 .. ari] :: [Word64] mapM_ (\i -> normalAtWith reduceAt book (loc + i)) ars return whnf _ -> do return whnf #54: normalAt :: Book -> Loc -> HVM Term normalAt = normalAtWith reduceAt #55: normalCAt :: Book -> Loc -> HVM Term normalCAt = normalAtWith $ \ _ host -> do term <- got host whnf <- reduce term set host whnf return $ whnf ./Compile.hs #56: -- //./Type.hs// -- //./Inject.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #79: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #80: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #81: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #82: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #83: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #84: -- Type.hs: -- //./Type.hs// #85: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #86: module Main where #87: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #88: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #89: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #90: -- Main -- ---- #91: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #92: -- CLI Commands -- ------------ #93: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #94: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #95: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #96: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #97: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #98: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #99: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #100: -- Normalize main -- init <- getCPUTime -- root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- done <- (if compiled then normalC else normal) book root -- norm <- doExtractCore book done -- end <- getCPUTime -- putStrLn $ coreToString norm #101: init <- getCPUTime root <- doInjectCoreAt book (Ref "main" (nameToId book MS.! "main") []) 0 [] norm <- (if compiled then normalCAt else normalAt) book 0 norm <- doExtractCore book norm end <- getCPUTime putStrLn $ coreToString norm #102: -- Show stats when showStats $ do itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #103: -- Finalize hvmFree return $ Right () #104: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #105: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #106: -- //./Runtime.c// #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: -- NOTE TO AI: we're now implementing the notion of unordered Sup and Dup nodes (USp and UDp). -- These work like Sup/Dup, except that the order of the elements / variables isn't relevant. -- That is, swapping the elements of an unordered superposition has no observable effect. -- Because of that, in the UDp case, both variables it binds are observationally equivalent. -- As such, we store it as just a single variable. Below are the syntaxes: -- UDp: `! %L{x} = value` -- USp: `%L{a b}` -- And it holds that `∀ a b . %L{a b} == %L{b a}`. -- Your goal is to help implementing the cases of the USp and UDp nodes. #111: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core | USp Word64 Core Core | UDp Word64 String Core Core deriving (Show, Eq) #112: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | UDP | APP | ERA | LAM | SUP | USP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_usp" reduceAppUsp :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_dup_usp" reduceDupUsp :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_mat_usp" reduceMatUsp :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opx_usp" reduceOpxUsp :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #165: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #166: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #167: foreign import ccall unsafe "Runtime.c reduce_opy_usp" reduceOpyUsp :: Term -> Term -> IO Term #168: foreign import ccall unsafe "Runtime.c reduce_udp_era" reduceUdpEra :: Term -> Term -> IO Term #169: foreign import ccall unsafe "Runtime.c reduce_udp_lam" reduceUdpLam :: Term -> Term -> IO Term #170: foreign import ccall unsafe "Runtime.c reduce_udp_sup" reduceUdpSup :: Term -> Term -> IO Term #171: foreign import ccall unsafe "Runtime.c reduce_udp_ctr" reduceUdpCtr :: Term -> Term -> IO Term #172: foreign import ccall unsafe "Runtime.c reduce_udp_w32" reduceUdpW32 :: Term -> Term -> IO Term #173: foreign import ccall unsafe "Runtime.c reduce_udp_usp" reduceUdpUsp :: Term -> Term -> IO Term #174: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #175: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #176: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #177: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #178: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #179: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #180: -- Constants -- --------- #181: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = UDP tagT 0x03 = VAR tagT 0x04 = SUB tagT 0x05 = REF tagT 0x06 = LET tagT 0x07 = APP tagT 0x08 = MAT tagT 0x09 = OPX tagT 0x0A = OPY tagT 0x0B = ERA tagT 0x0C = LAM tagT 0x0D = SUP tagT 0x0E = USP tagT 0x0F = CTR tagT 0x10 = W32 tagT tag = error $ "unknown tag: " ++ show tag #182: _DP0_, _DP1_, _VAR_, _SUB_, _UDP_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _USP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _UDP_ = 0x02 _VAR_ = 0x03 _SUB_ = 0x04 _REF_ = 0x05 _LET_ = 0x06 _APP_ = 0x07 _MAT_ = 0x08 _OPX_ = 0x09 _OPY_ = 0x0A _ERA_ = 0x0B _LAM_ = 0x0C _SUP_ = 0x0D _USP_ = 0x0E _CTR_ = 0x0F _W32_ = 0x10 #183: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #184: //./Type.hs// #185: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #186: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #187: typedef _Atomic(Term) ATerm; #188: // Runtime Types // ------------- #189: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions u64* adts; // ADT Info } State; #190: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #191: // Constants // --------- #192: #define DP0 0x00 #define DP1 0x01 #define UDP 0x02 #define VAR 0x03 #define SUB 0x04 #define REF 0x05 #define LET 0x06 #define APP 0x07 #define MAT 0x08 #define OPX 0x09 #define OPY 0x0A #define ERA 0x0B #define LAM 0x0C #define SUP 0x0D #define USP 0x0E #define CTR 0x0F #define W32 0x10 #193: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #194: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #195: #define VOID 0x00000000000000 #196: // Heap // ---- #197: Loc get_len() { return *HVM.size; } #198: u64 get_itr() { return *HVM.itrs; } #199: void set_len(Loc value) { *HVM.size = value; } #200: void set_itr(Loc value) { *HVM.itrs = value; } #201: // Terms // ------ #202: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #203: Tag term_tag(Term x) { return x & 0xFF; } #204: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #205: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #206: Loc term_key(Term term) { switch (term_tag(term)) { case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; case UDP: return term_loc(term) + 0; case VAR: return term_loc(term) + 0; default: return 0; } } #207: // u12v2 // ----- #208: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #209: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #210: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #211: // Atomics // ------- #212: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #213: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #214: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #215: Term take(Loc loc) { return swap(loc, VOID); } #216: // Allocation // ---------- #217: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #218: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #219: // Stringification // --------------- #220: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; case UDP: printf("UDP"); break; case USP: printf("USP"); break; default : printf("???"); break; } } #221: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #222: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #223: // Evaluation // ---------- #224: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #225: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #226: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #227: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #228: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #229: // (%L{a b} c) // --------------- APP-USP // ! %L{x} = c // %L{(a x) (b x)} Term reduce_app_usp(Term app, Term usp) { inc_itr(); Loc app_loc = term_loc(app); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term arg = got(app_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); Term cop; if (term_tag(arg) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, arg); cop = term_new(UDP, usp_lab, du0); } else { cop = arg; } set(ap0 + 0, tm0); set(ap0 + 1, cop); set(ap1 + 0, tm1); set(ap1 + 1, cop); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(USP, usp_lab, su0); } #230: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #231: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #232: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #233: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #234: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #235: // ! &L{x y} = %R{a b} // ------------------- DUP-USP // x <- %R{a0 b0} // y <- %R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_usp(Term dup, Term usp) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc us0 = alloc_node(2); Loc us1 = alloc_node(2); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(us0 + 0, term_new(DP0, dup_lab, du0)); set(us0 + 1, term_new(DP0, dup_lab, du1)); set(us1 + 0, term_new(DP1, dup_lab, du0)); set(us1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(USP, usp_lab, us0)); set(dup_loc + 1, term_new(USP, usp_lab, us1)); return got(dup_loc + dup_num); } #236: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #237: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #238: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #239: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #240: // TODO: treat SUP label // ~ &{x y} {K0 K1 K2 ...} // ----------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // &{ ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #241: // MAT_USP: TODO // ~ %L{x y} {K0 K1 K2 ...} // ------------------------ MAT-USP // ! %L{k0} = K0 // ! %L{k1} = K1 // ! %L{k2} = K2 // ... // %L{ ~ x {K0 K1 K2 ...} // ~ y {K0 K1 K2 ...} } Term reduce_mat_usp(Term mat, Term usp) { inc_itr(); Loc mat_loc = term_loc(mat); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Lab mat_len = term_lab(mat); Loc usp0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Term cse = got(mat_loc + 1 + i); Term cop; if (term_tag(cse) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(mat_loc + 1 + i)); cop = term_new(UDP, usp_lab, du0); } else { cop = cse; } set(mat0 + 1 + i, cop); set(mat1 + 1 + i, cop); } set(usp0 + 0, term_new(MAT, mat_len, mat0)); set(usp0 + 1, term_new(MAT, mat_len, mat1)); return term_new(USP, usp_lab, usp0); } #242: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #243: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #244: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #245: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #246: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #247: // <op(%L{x0 x1} y) // ------------------------- OPX-USP // ! %L{y0} = y // %L{<op(x0 y0) <op(x1 y0)} Term reduce_opx_usp(Term opx, Term usp) { //printf("opx-usp\n"); inc_itr(); Loc opx_loc = term_loc(opx); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmy = got(opx_loc + 1); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); Term cop; if (term_tag(nmy) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, nmy); cop = term_new(UDP, usp_lab, du0); } else { cop = nmy; } set(op0 + 0, tm0); set(op0 + 1, cop); set(op1 + 0, tm1); set(op1 + 1, cop); set(us0 + 0, term_new(OPX, term_lab(opx), op0)); set(us0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(USP, usp_lab, us0); } #248: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #249: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #250: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #251: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #252: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #253: // >op(a %L{x y}) // --------------------- OPY-USP // %L{>op(a x) >op(a y)} Term reduce_opy_usp(Term opy, Term usp) { inc_itr(); Loc opy_loc = term_loc(opy); Loc usp_loc = term_loc(usp); Lab usp_lab = term_lab(usp); Term nmx = got(opy_loc + 0); Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc us0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(us0 + 0, term_new(OPY, term_lab(opy), op0)); set(us0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(USP, usp_lab, us0); } #254: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #255: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #256: // ! %L{x} = * // ----------- UDP-ERA // x <- * Term reduce_udp_era(Term udp, Term era) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, era); return era; } #257: // ! &L{F} = λx(f) // ----------------- UDP-LAM // ! &L{G} = f // F <- λx0(G) // F <- λx1(G) // x <- &L{x0 x1} Term reduce_udp_lam(Term udp, Term lam) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); Term cop; if (term_tag(bod) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, bod); cop = term_new(UDP, udp_lab, du0); } else { cop = bod; } set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, cop); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, cop); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(udp_loc + 0, term_new(LAM, 0, lm0)); set(lam_loc + 0, term_new(USP, udp_lab, su0)); return got(udp_loc + 0); } #258: // TODO: UDP-SUP Term reduce_udp_sup(Term udp, Term sup) { printf("TODO:udp-sup\n"); exit(0); } #259: // ! %L{x} = %R{a b} // ------------------- UDP-USP // if L == R: // x <- b // a // else: // TODO Term reduce_udp_usp(Term udp, Term usp) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Lab usp_lab = term_lab(usp); Loc usp_loc = term_loc(usp); if (udp_lab == usp_lab) { Term tm0 = got(usp_loc + 0); Term tm1 = got(usp_loc + 1); set(udp_loc + 0, tm1); return tm0; } else { printf("TODO:udp-usp\n"); exit(0); } } #260: // ! %L{x} = #{a b c ...} // ---------------------- UDP-CTR // x <- #{ax bx cx ...} // ! %L{ax} = a // ! %L{bx} = b // ! %L{cx} = c // ... // #{ax bx cx ...} // NOTE: this must create two separate CTRs Term reduce_udp_ctr(Term udp, Term ctr) { inc_itr(); Loc udp_loc = term_loc(udp); Lab udp_lab = term_lab(udp); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ct0 = alloc_node(ctr_ari); Loc ct1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Term fld = got(ctr_loc + i); Term cop; if (term_tag(fld) != UDP) { Loc du0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, got(ctr_loc + i)); cop = term_new(UDP, udp_lab, du0); } else { cop = fld; } set(ct0 + i, cop); set(ct1 + i, cop); } set(udp_loc + 0, term_new(CTR, ctr_lab, ct1)); return term_new(CTR, ctr_lab, ct0); } #261: // ! %L{x} = 123 // ------------- UDP-W32 // x <- 123 // 123 Term reduce_udp_w32(Term udp, Term w32) { inc_itr(); Loc udp_loc = term_loc(udp); set(udp_loc + 0, w32); return w32; } #262: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case UDP: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; case USP: next = reduce_app_usp(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; case USP: next = reduce_dup_usp(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; case USP: next = reduce_mat_usp(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; case USP: next = reduce_opx_usp(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; case USP: next = reduce_opy_usp(prev, next); continue; default: break; } } case UDP: { switch (tag) { case ERA: next = reduce_udp_era(prev, next); continue; case LAM: next = reduce_udp_lam(prev, next); continue; case SUP: next = reduce_udp_sup(prev, next); continue; case CTR: next = reduce_udp_ctr(prev, next); continue; case W32: next = reduce_udp_w32(prev, next); continue; case USP: next = reduce_udp_usp(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #263: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #264: // Runtime Memory // -------------- #265: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #266: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #267: State* hvm_get_state() { return &HVM; } #268: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #269: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #270: -- //./Type.hs// #271: module HVML.Extract where #272: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #273: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #274: extractCore :: Book -> Term -> ExtractM Core extractCore book term = case tagT (termTag term) of ERA -> do return Era #275: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore book val bod0 <- extractCore book bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore book bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore book fun arg0 <- extractCore book arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore book sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore book sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore book sub #276: UDP -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, _) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) val <- lift $ got (loc + 1) modify $ \x -> (IS.insert (fromIntegral loc) dups, snd x) val0 <- extractCore book val return $ UDp lab dp0 val0 (Var dp0) else extractCore book sub #277: USP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore book tm0 tm10 <- extractCore book tm1 return $ USp lab tm00 tm10 CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM (extractCore book) fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore book val css0 <- mapM (extractCore book) css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore book nm0 nm10 <- extractCore book nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg0 <- mapM (extractCore book) arg let name = MS.findWithDefault "?" fid (idToName book) return $ Ref name fid arg0 _ -> return Era #278: doExtractCore :: Book -> Term -> HVM Core doExtractCore book term = do core <- evalStateT (extractCore book term) (IS.empty, MS.empty) return $ doLiftDups core #279: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #280: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 #281: -- Lifting Dups -- ------------ #282: liftDups :: Core -> State (Core -> Core) Core liftDups (Var nam) = return $ Var nam liftDups (Ref nam fid arg) = do arg <- mapM liftDups arg return $ Ref nam fid arg liftDups Era = return Era liftDups (Lam str bod) = do bod <- liftDups bod return $ Lam str bod liftDups (App fun arg) = do fun <- liftDups fun arg <- liftDups arg return $ App fun arg liftDups (Sup lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ Sup lab tm0 tm1 liftDups (Dup lab dp0 dp1 val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (Dup lab dp0 dp1 val k)) return bod liftDups (Ctr cid fds) = do fds <- mapM liftDups fds return $ Ctr cid fds liftDups (Mat val css) = do val <- liftDups val css <- mapM (\(ar, cs) -> do cs <- liftDups cs return (ar, cs)) css return $ Mat val css liftDups (U32 val) = return $ U32 val liftDups (Op2 opr nm0 nm1) = do nm0 <- liftDups nm0 nm1 <- liftDups nm1 return $ Op2 opr nm0 nm1 liftDups (Let mod nam val bod) = do val <- liftDups val bod <- liftDups bod return $ Let mod nam val bod liftDups (USp lab tm0 tm1) = do tm0 <- liftDups tm0 tm1 <- liftDups tm1 return $ USp lab tm0 tm1 liftDups (UDp lab dp val bod) = do val <- liftDups val bod <- liftDups bod modify (\oldState k -> oldState (UDp lab dp val k)) return bod #283: doLiftDups :: Core -> Core doLiftDups term = let (liftedTerm, finalState) = runState (liftDups term) id in finalState liftedTerm ./Inject.hs #284: module HVML.Inject where #285: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #286: type InjectM a = StateT InjectState HVM a #287: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #288: emptyState :: InjectState emptyState = InjectState Map.empty [] #289: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #290: injectCore _ (Var nam) loc = do args <- gets args case Map.lookup nam args of Just term -> lift $ set loc term Nothing -> modify $ \s -> s { vars = (nam, loc) : vars s } #291: injectCore book (Let mod nam val bod) loc = do let_node <- lift $ allocNode 3 lift $ set (let_node + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (let_node + 0)) (args s) } injectCore book val (let_node + 1) injectCore book bod (let_node + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mod) let_node) #292: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #293: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #294: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #295: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #296: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #297: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #298: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #299: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #300: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #301: injectCore book (USp lab tm0 tm1) loc = do usp <- lift $ allocNode 2 injectCore book tm0 (usp + 0) injectCore book tm1 (usp + 1) lift $ set loc (termNew _USP_ lab usp) #302: injectCore book (UDp lab dp0 val bod) loc = do udp <- lift $ allocNode 2 lift $ set (udp + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _UDP_ lab udp) (args s) } injectCore book val (udp + 1) injectCore book bod loc #303: doInjectCoreAt :: Book -> Core -> Loc -> [(String, Term)] -> HVM Term doInjectCoreAt book core host argList = do (_, state) <- runStateT (injectCore book core host) (emptyState { args = Map.fromList argList }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got host

54b2f12168ca10045267a84893e155f28d2e0096

implement let, seq; can express mutable refs now; par = later

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #80: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #81: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #82: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #83: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #84: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #85: -- Type.hs: -- //./Type.hs// #86: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #87: module Main where #88: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #89: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #90: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #91: -- Main -- ---- #92: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #93: -- CLI Commands -- ------------ #94: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #95: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #96: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #97: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #98: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #99: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #100: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #101: -- Normalize main init <- getCPUTime #102: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #103: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #104: -- Finalize hvmFree return $ Right () #105: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #106: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #111: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #112: type Func = ([String], Core) #113: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #114: -- Runtime Types -- ------------- #115: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #116: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #117: type HVM = IO #118: -- C Functions -- ----------- #119: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #120: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #121: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #122: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #123: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #124: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #125: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #127: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #128: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #129: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #130: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #131: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #132: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #133: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #134: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #135: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #136: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #161: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #162: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #163: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #164: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #165: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #166: -- Constants -- --------- #167: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #168: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #169: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #170: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #171: typedef _Atomic(Term) ATerm; #172: // Runtime Types // ------------- #173: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #174: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #175: // Constants // --------- #176: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #177: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #178: #define VOID 0x00000000000000 #179: // Heap // ---- #180: Loc get_len() { return *HVM.size; } #181: u64 get_itr() { return *HVM.itrs; } #182: void set_len(Loc value) { *HVM.size = value; } #183: void set_itr(Loc value) { *HVM.itrs = value; } #184: // Terms // ------ #185: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #186: Tag term_tag(Term x) { return x & 0xFF; } #187: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #188: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #189: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #190: // u12v2 // ----- #191: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #192: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #193: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #194: // Atomics // ------- #195: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #196: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #197: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term take(Loc loc) { return swap(loc, VOID); } #199: // Allocation // ---------- #200: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #201: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #202: // Stringification // --------------- #203: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #204: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #205: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #206: // Evaluation // ---------- #207: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #208: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #209: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #210: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #211: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #212: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #213: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #214: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #215: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #216: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #218: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #219: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #220: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #221: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #222: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #223: // TODO: now, let's implement the missing OPX interactions. #224: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #225: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #226: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #227: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #228: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #229: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #230: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #231: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #232: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #233: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #234: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #235: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #236: // Runtime Memory // -------------- #237: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #238: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #239: State* hvm_get_state() { return &HVM; } #240: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #241: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #242: -- //./Type.hs// #243: module HVML.Extract where #244: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #245: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #246: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #247: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #248: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #249: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #250: -- //./Type.hs// #251: module HVML.Inject where #252: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #253: type InjectM a = StateT InjectState HVM a #254: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #255: emptyState :: InjectState emptyState = InjectState Map.empty [] #256: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #257: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #258: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #259: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #260: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #261: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #262: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #263: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #264: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #265: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #266: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #267: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" coreToString (Let mod nam val bod) = "! " ++ modeToString mod ++ nam ++ " = " ++ coreToString val ++ " " ++ coreToString bod #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: modeToString LAZY = "" modeToString STRI = "." modeToString PARA = "^" #8: -- Runtime Stringification -- ----------------------- #9: tagToString :: Tag -> String tagToString t = show (tagT t) #10: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #11: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #12: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #13: -- Dumping -- ------- #14: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #15: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #16: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #17: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #18: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #19: -- //./Type.hs// -- //./Show.hs// #20: module HVML.Parse where #21: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #22: -- Core Parsers -- ------------ #23: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #24: type ParserM = Parsec String ParserState #25: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 -- '!' -> do -- consume "!" -- consume "&" -- lab <- read <$> many1 digit -- consume "{" -- dp0 <- parseName -- dp1 <- parseName -- consume "}" -- consume "=" -- val <- parseCore -- bod <- parseCore -- return $ Dup lab dp0 dp1 val bod -- TODO: implement the 'let' parser. -- it will be implemented in the same parser as Dup, as follows: -- if we parse "!" then "&", that's a dup -- if we parse "!" then ".", that's a strict let -- if we parse "!" then "^", that's a parallel let -- otherwise, that's a lazy let. -- create a case-of for the next character, just like we did in other parsers '!' -> do consume "!" skip next <- lookAhead anyChar case next of '&' -> do -- parsing 'dup' consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '!' -> do -- parsing strict 'let' consume "!" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let STRI nam val bod '^' -> do -- parsing parallel 'let' consume "^" nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let PARA nam val bod _ -> do -- parsing lazy 'let' nam <- parseName consume "=" val <- parseCore bod <- parseCore return $ Let LAZY nam val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #26: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #27: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #28: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #29: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #30: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #31: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #32: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #33: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #34: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #35: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #36: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #37: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #38: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #39: -- Helper Parsers -- -------------- #40: consume :: String -> ParserM String consume str = spaces >> string str #41: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #42: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #43: -- Adjusting -- --------- #44: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #45: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Let m x v b -> Let m x (decorateFnIds fids v) (decorateFnIds fids b) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #46: -- Errors -- ------ #47: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #48: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #49: -- //./Type.hs// #50: module HVML.Reduce where #51: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #52: import Debug.Trace #53: -- debug a b = trace a b debug a b = b #54: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of LET -> do case modeT lab of LAZY -> do val <- got (loc + 1) bod <- reduceLet term val reduce book bod STRI -> do val <- got (loc + 1) val <- reduce book val bod <- reduceLet term val reduce book bod PARA -> do error "TODO" APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #55: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #56: normal :: Book -> Term -> HVM Term normal = normalizer reduce #57: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #58: -- //./Type.hs// -- //./Inject.hs// #59: module HVML.Compile where #60: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #61: import Debug.Trace #62: -- Compilation -- ----------- #63: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #64: type Compile = State CompileState #65: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #66: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #67: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #68: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #69: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #70: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #71: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #72: -- Full Compiler -- ------------- #73: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #74: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #75: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Let mode var val bod) host = do letNam <- fresh "let" emit $ "Loc " ++ letNam ++ " = alloc_node(3);" emit $ "set(" ++ letNam ++ " + 0, term_new(SUB, 0, 0));" valT <- compileFullCore book fid val (letNam ++ " + 1") emit $ "set(" ++ letNam ++ " + 1, " ++ valT ++ ");" bind var $ "term_new(VAR, 0, " ++ letNam ++ " + 0)" bodT <- compileFullCore book fid bod (letNam ++ " + 2") emit $ "set(" ++ letNam ++ " + 2, " ++ bodT ++ ");" return $ "term_new(LET, " ++ show (fromEnum mode) ++ ", " ++ letNam ++ ")" compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #76: -- Fast Compiler -- ------------- #77: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #78: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #79: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #80: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #81: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #82: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #83: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Let mode var val bod) = do valT <- compileFastCore book fid val case mode of LAZY -> do bind var valT STRI -> do valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam PARA -> do -- TODO: implement parallel evaluation valNam <- fresh "val" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" bind var valNam compileFastCore book fid bod compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #84: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #85: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #86: -- Type.hs: -- //./Type.hs// #87: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #88: module Main where #89: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #90: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #91: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #92: -- Main -- ---- #93: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #94: -- CLI Commands -- ------------ #95: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #96: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #97: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #98: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #99: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #100: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #101: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #102: -- Normalize main init <- getCPUTime #103: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #104: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #105: -- Finalize hvmFree return $ Right () #106: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #107: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #108: module HVML.Type where #109: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #110: -- IMPORTANT - NOTE TO AI: -- We're now adding the 'Let' constructor to HVM. -- All files must be updated to include it. #111: -- Core Types -- ---------- #112: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core | Let Mode String Core Core deriving (Show, Eq) #113: data Mode = LAZY | STRI | PARA deriving (Show, Eq, Enum) #114: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #115: type Func = ([String], Core) #116: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #117: -- Runtime Types -- ------------- #118: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #119: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | LET | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #120: type HVM = IO #121: -- C Functions -- ----------- #122: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #123: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #124: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #125: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #126: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #129: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #130: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #131: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #132: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #134: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #135: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #137: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_let" reduceLet :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #163: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #164: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #165: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #166: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #167: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #168: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #169: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #170: -- Constants -- --------- #171: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = LET tagT 0x06 = APP tagT 0x07 = MAT tagT 0x08 = OPX tagT 0x09 = OPY tagT 0x0A = ERA tagT 0x0B = LAM tagT 0x0C = SUP tagT 0x0D = CTR tagT 0x0E = W32 tagT tag = error $ "unknown tag: " ++ show tag #172: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _LET_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _LET_ = 0x05 _APP_ = 0x06 _MAT_ = 0x07 _OPX_ = 0x08 _OPY_ = 0x09 _ERA_ = 0x0A _LAM_ = 0x0B _SUP_ = 0x0C _CTR_ = 0x0D _W32_ = 0x0E #173: modeT :: Lab -> Mode modeT 0x00 = LAZY modeT 0x01 = STRI modeT 0x02 = PARA modeT mode = error $ "unknown mode: " ++ show mode ./Runtime.c #174: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #175: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #176: typedef _Atomic(Term) ATerm; #177: // Runtime Types // ------------- #178: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #179: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #180: // Constants // --------- #181: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define LET 0x05 #define APP 0x06 #define MAT 0x07 #define OPX 0x08 #define OPY 0x09 #define ERA 0x0A #define LAM 0x0B #define SUP 0x0C #define CTR 0x0D #define W32 0x0E #182: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #183: #define LAZY 0x0 #define STRI 0x1 #define PARA 0x2 #184: #define VOID 0x00000000000000 #185: // Heap // ---- #186: Loc get_len() { return *HVM.size; } #187: u64 get_itr() { return *HVM.itrs; } #188: void set_len(Loc value) { *HVM.size = value; } #189: void set_itr(Loc value) { *HVM.itrs = value; } #190: // Terms // ------ #191: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #192: Tag term_tag(Term x) { return x & 0xFF; } #193: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #194: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #195: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #196: // u12v2 // ----- #197: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #198: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #199: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #200: // Atomics // ------- #201: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #202: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #203: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #204: Term take(Loc loc) { return swap(loc, VOID); } #205: // Allocation // ---------- #206: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #207: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #208: // Stringification // --------------- #209: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case LET: printf("LET"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #210: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #211: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #212: // Evaluation // ---------- #213: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #214: // ! x = val // bod // --------- LET // x <- val // bod Term reduce_let(Term let, Term val) { inc_itr(); Loc let_loc = term_loc(let); Term bod = got(let_loc + 2); set(let_loc + 0, val); return bod; } #215: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #216: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #217: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #218: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #219: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #220: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #221: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #222: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #223: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #224: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #225: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #226: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #227: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #228: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #229: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #230: // TODO: now, let's implement the missing OPX interactions. #231: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #232: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #233: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #234: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #235: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #236: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #237: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #238: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #239: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #240: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #241: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case LET: { switch (lab) { case LAZY: { next = reduce_let(next, got(loc + 1)); continue; } case STRI: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case PARA: { printf("TODO\n"); continue; } } } case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case LET: { next = reduce_let(prev, next); continue; } case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #242: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #243: // Runtime Memory // -------------- #244: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #245: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #246: State* hvm_get_state() { return &HVM; } #247: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #248: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #249: -- //./Type.hs// -- //./Inject.hs// #250: module HVML.Extract where #251: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #252: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #253: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era #254: LET -> do let loc = termLoc term let mode = modeT (termLab term) val <- lift $ got (loc + 1) bod <- lift $ got (loc + 2) name <- genName (loc + 0) val0 <- extractCore val bod0 <- extractCore bod return $ Let mode name val0 bod0 LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #255: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #256: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #257: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #258: -- //./Type.hs// -- //./Show.hs// #259: module HVML.Inject where #260: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #261: type InjectM a = StateT InjectState HVM a #262: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #263: emptyState :: InjectState emptyState = InjectState Map.empty [] #264: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #265: injectCore book (Let mode nam val bod) loc = do lit <- lift $ allocNode 3 lift $ set (lit + 0) (termNew _SUB_ 0 0) injectCore book val (lit + 1) modify $ \s -> s { args = Map.insert nam (termNew _VAR_ 0 (lit + 0)) (args s) } injectCore book bod (lit + 2) lift $ set loc (termNew _LET_ (fromIntegral $ fromEnum mode) lit) #266: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #267: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #268: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #269: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #270: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #271: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #272: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #273: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #274: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #275: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #276: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

971d16b8c07ab129b4c63370563d93b24694d701

optimization / bugfix: dont call reduce on body - seq operator will be added

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #80: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #81: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #82: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = reduce(" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = reduce(" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #83: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #84: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" #85: TASK: find and report any obvious bug or typo you find. write below the full overview in ENGLISH: #86: An obvious bug in the code is in the `compileFastCore` function when handling the `Op2` case. The code does not distinguish between arithmetic and logical operations when creating the operation nodes. Specifically, it always creates an `OPX` node, regardless of the operator. However, some operators should use `OPX` (e.g., arithmetic operators like addition and subtraction), while others should use `OPY` (e.g., comparison operators like equal and less than). To fix this, the code should select the appropriate tag (`OPX` or `OPY`) based on the operator being compiled. ./Main.hs #87: -- Type.hs: -- //./Type.hs// #88: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #89: module Main where #90: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #91: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #92: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #93: -- Main -- ---- #94: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #95: -- CLI Commands -- ------------ #96: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #97: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #98: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #99: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #100: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #101: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #102: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #103: -- Normalize main init <- getCPUTime #104: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #105: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #106: -- Finalize hvmFree return $ Right () #107: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #108: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #109: module HVML.Type where #110: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #111: -- Core Types -- ---------- #112: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #163: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #164: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #165: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #166: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #168: -- Constants -- --------- #169: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #170: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #171: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #172: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #173: typedef _Atomic(Term) ATerm; #174: // Runtime Types // ------------- #175: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #176: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #177: // Constants // --------- #178: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #179: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #180: #define VOID 0x00000000000000 #181: // Heap // ---- #182: Loc get_len() { return *HVM.size; } #183: u64 get_itr() { return *HVM.itrs; } #184: void set_len(Loc value) { *HVM.size = value; } #185: void set_itr(Loc value) { *HVM.itrs = value; } #186: // Terms // ------ #187: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #188: Tag term_tag(Term x) { return x & 0xFF; } #189: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #190: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #191: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #192: // u12v2 // ----- #193: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #194: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #195: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #196: // Atomics // ------- #197: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #199: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #200: Term take(Loc loc) { return swap(loc, VOID); } #201: // Allocation // ---------- #202: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #203: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #204: // Stringification // --------------- #205: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #206: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #207: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #208: // Evaluation // ---------- #209: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #210: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #211: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #212: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #213: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #214: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #215: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #216: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #218: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #219: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #220: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #221: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #222: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #223: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #224: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #225: // TODO: now, let's implement the missing OPX interactions. #226: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #227: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #228: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #229: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #230: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #231: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #232: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #233: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #234: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #235: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #236: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #237: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #238: // Runtime Memory // -------------- #239: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #240: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #241: State* hvm_get_state() { return &HVM; } #242: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #243: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #244: -- //./Type.hs// #245: module HVML.Extract where #246: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #247: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #248: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #249: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #250: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #251: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #252: -- //./Type.hs// #253: module HVML.Inject where #254: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> #270: case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: String -> Compile String fresh name = do uid <- gets next modify $ \s -> s { next = uid + 1 } return $ name ++ show uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFullCore book fid bod (lamNam ++ " + 1") emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFullCore book fid (App fun arg) host = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appNam ++ " + 0") argT <- compileFullCore book fid arg (appNam ++ " + 1") emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supNam ++ " + 0") tm1T <- compileFullCore book fid tm1 (supNam ++ " + 1") emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do dupNam <- fresh "dup" emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0)" valT <- compileFullCore book fid val (dupNam ++ " + 2") emit $ "set(" ++ dupNam ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrNam ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFullCore book fid (Mat val css) host = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matNam ++ " + 0") emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matNam ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxNam <- fresh "opx" emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refNam ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argNam <- fresh "arg" emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valNam <- fresh "val" numNam <- fresh "num" emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preNam <- fresh "pre" emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrNam <- fresh "ctr" emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #80: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #81: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #82: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do lamNam <- fresh "lam" emit $ "Loc " ++ lamNam ++ " = alloc_node(2);" emit $ "set(" ++ lamNam ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamNam ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamNam ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamNam ++ ")" compileFastCore book fid (App fun arg) = do appNam <- fresh "app" emit $ "Loc " ++ appNam ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appNam ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appNam ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appNam ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do supNam <- fresh "sup" emit $ "Loc " ++ supNam ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supNam ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supNam ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supNam ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupNam <- fresh "dup" dp0Nam <- fresh "dp0" dp1Nam <- fresh "dp1" valNam <- fresh "val" valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = (" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do ctrNam <- fresh "ctr" let arity = length fds emit $ "Loc " ++ ctrNam ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrNam ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrNam ++ ")" compileFastCore book fid (Mat val css) = do matNam <- fresh "mat" let arity = length css emit $ "Loc " ++ matNam ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matNam ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matNam ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matNam ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxNam <- fresh "opx" retNam <- fresh "ret" nu0Nam <- fresh "nu0" nu1Nam <- fresh "nu1" nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = (" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = (" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do refNam <- fresh "ref" let arity = length rArg emit $ "Loc " ++ refNam ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refNam ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refNam ++ ")" #83: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #84: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #85: -- Type.hs: -- //./Type.hs// #86: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #87: module Main where #88: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #89: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #90: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #91: -- Main -- ---- #92: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #93: -- CLI Commands -- ------------ #94: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #95: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #96: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #97: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #98: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #99: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #100: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #101: -- Normalize main init <- getCPUTime #102: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #103: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #104: -- Finalize hvmFree return $ Right () #105: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #106: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #111: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #112: type Func = ([String], Core) #113: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #114: -- Runtime Types -- ------------- #115: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #116: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #117: type HVM = IO #118: -- C Functions -- ----------- #119: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #120: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #121: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #122: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #123: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #124: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #125: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #127: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #128: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #129: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #130: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #131: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #132: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #133: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #134: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #135: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #136: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #161: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #162: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #163: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #164: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #165: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #166: -- Constants -- --------- #167: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #168: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #169: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #170: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #171: typedef _Atomic(Term) ATerm; #172: // Runtime Types // ------------- #173: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #174: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #175: // Constants // --------- #176: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #177: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #178: #define VOID 0x00000000000000 #179: // Heap // ---- #180: Loc get_len() { return *HVM.size; } #181: u64 get_itr() { return *HVM.itrs; } #182: void set_len(Loc value) { *HVM.size = value; } #183: void set_itr(Loc value) { *HVM.itrs = value; } #184: // Terms // ------ #185: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #186: Tag term_tag(Term x) { return x & 0xFF; } #187: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #188: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #189: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #190: // u12v2 // ----- #191: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #192: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #193: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #194: // Atomics // ------- #195: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #196: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #197: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term take(Loc loc) { return swap(loc, VOID); } #199: // Allocation // ---------- #200: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #201: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #202: // Stringification // --------------- #203: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #204: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #205: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #206: // Evaluation // ---------- #207: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #208: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #209: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #210: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #211: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #212: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #213: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #214: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #215: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #216: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #218: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #219: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #220: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #221: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #222: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #223: // TODO: now, let's implement the missing OPX interactions. #224: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #225: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #226: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #227: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #228: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #229: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #230: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #231: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #232: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #233: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #234: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #235: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #236: // Runtime Memory // -------------- #237: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #238: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #239: State* hvm_get_state() { return &HVM; } #240: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #241: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #242: -- //./Type.hs// #243: module HVML.Extract where #244: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #245: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #246: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #247: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #248: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #249: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #250: -- //./Type.hs// #251: module HVML.Inject where #252: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #253: type InjectM a = StateT InjectState HVM a #254: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #255: emptyState :: InjectState emptyState = InjectState Map.empty [] #256: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #257: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #258: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #259: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #260: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #261: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #262: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #263: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #264: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #265: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #266: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #267: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

4dc954c5fbd80bf33afc737979f9dec7e7912c80

compile operators in fast-mode

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFullCore book fid bod (lamName ++ " + 1") emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFullCore book fid (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appName ++ " + 0") argT <- compileFullCore book fid arg (appName ++ " + 1") emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supName ++ " + 0") tm1T <- compileFullCore book fid tm1 (supName ++ " + 1") emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ "Loc " ++ dupName ++ " = alloc_node(3);" emit $ "set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileFullCore book fid val (dupName ++ " + 2") emit $ "set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFullCore book fid (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matName ++ " + 0") emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refName ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argUid <- fresh argNam <- return $ "arg" ++ show argUid emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valUid <- fresh valNam <- return $ "val" ++ show valUid numUid <- fresh numNam <- return $ "num" ++ show numUid emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preUid <- fresh preNam <- return $ "pre" ++ show preUid emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrUid <- fresh ctrNam <- return $ "ctr" ++ show ctrUid emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- compileFastBody book fid term ctx itr = do -- let (callFid, callArgs) = getCall term -- -- trace (coreToString term ++ " ||| " ++ show (length callArgs) ++ " " ++ show (length ctx) ++ " " ++ show callFid ++ " " ++ show fid) $ do -- if length callArgs == length ctx && callFid == fid then do -- forM_ (zip callArgs ctx) $ \ (arg, ctxVar) -> do -- argT <- compileFastCore book fid arg -- emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" -- emit $ "itrs += " ++ show (length ctx + itr + 1) ++ ";" -- emit $ "continue;" -- else do -- emit $ "itrs += " ++ show (length ctx + itr) ++ ";" -- body <- compileFastCore book fid term -- compileFastSave book fid term ctx itr -- emit $ "return " ++ body ++ ";" -- where -- getCall :: Core -> (Word64, [Core]) -- getCall = go [] where -- go ctx (App f x) = go (x:ctx) f -- go ctx (Ref _ i) = (i, ctx) -- go ctx term = (0xFFFFFFFF, ctx) #80: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #81: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #82: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #83: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFastCore book fid (App fun arg) = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupUid <- fresh dupNam <- return $ "dup" ++ show dupUid dp0Uid <- fresh dp0Nam <- return $ "dp0" ++ show dp0Uid dp1Uid <- fresh dp1Nam <- return $ "dp1" ++ show dp1Uid valUid <- fresh valNam <- return $ "val" ++ show valUid valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFastCore book fid (Mat val css) = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid retUid <- fresh retNam <- return $ "ret" ++ show retUid nu0Uid <- fresh nu0Nam <- return $ "nu0" ++ show nu0Uid nu1Uid <- fresh nu1Nam <- return $ "nu1" ++ show nu1Uid nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = reduce(" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = reduce(" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") + term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #84: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #85: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #86: -- Type.hs: -- //./Type.hs// #87: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #88: module Main where #89: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #90: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #91: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #92: -- Main -- ---- #93: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #94: -- CLI Commands -- ------------ #95: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #96: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #97: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #98: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #99: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #100: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #101: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #102: -- Normalize main init <- getCPUTime #103: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #104: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #105: -- Finalize hvmFree return $ Right () #106: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #107: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #108: module HVML.Type where #109: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #110: -- Core Types -- ---------- #111: -- NOTE TO AI: we're refactoring REF. Now, instead of nullary (like '@foo'), it -- will hold a list of arguments (like '(@foo A B C ...)'). As such, it is -- compiled similarly to constructors, and must allocate a space for each arg. #112: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #163: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #164: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #165: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #166: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #168: -- Constants -- --------- #169: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #170: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #171: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #172: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #173: typedef _Atomic(Term) ATerm; #174: // Runtime Types // ------------- #175: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #176: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #177: // Constants // --------- #178: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #179: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #180: #define VOID 0x00000000000000 #181: // Heap // ---- #182: Loc get_len() { return *HVM.size; } #183: u64 get_itr() { return *HVM.itrs; } #184: void set_len(Loc value) { *HVM.size = value; } #185: void set_itr(Loc value) { *HVM.itrs = value; } #186: // Terms // ------ #187: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #188: Tag term_tag(Term x) { return x & 0xFF; } #189: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #190: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #191: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #192: // u12v2 // ----- #193: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #194: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #195: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #196: // Atomics // ------- #197: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #199: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #200: Term take(Loc loc) { return swap(loc, VOID); } #201: // Allocation // ---------- #202: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #203: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #204: // Stringification // --------------- #205: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #206: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #207: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #208: // Evaluation // ---------- #209: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #210: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #211: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #212: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #213: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #214: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #215: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #216: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #218: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #219: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #220: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #221: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #222: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #223: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #224: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #225: // TODO: now, let's implement the missing OPX interactions. #226: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #227: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #228: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #229: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #230: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #231: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #232: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #233: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #234: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #235: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #236: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #237: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #238: // Runtime Memory // -------------- #239: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #240: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #241: State* hvm_get_state() { return &HVM; } #242: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #243: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #244: -- //./Type.hs// #245: module HVML.Extract where #246: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #247: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #248: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: arity hint is lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #249: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #250: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #251: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #252: -- //./Type.hs// #253: module HVML.Inject where #254: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> #270: case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFullCore book fid bod (lamName ++ " + 1") emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFullCore book fid (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appName ++ " + 0") argT <- compileFullCore book fid arg (appName ++ " + 1") emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supName ++ " + 0") tm1T <- compileFullCore book fid tm1 (supName ++ " + 1") emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ "Loc " ++ dupName ++ " = alloc_node(3);" emit $ "set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileFullCore book fid val (dupName ++ " + 2") emit $ "set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFullCore book fid (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matName ++ " + 0") emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refName ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argUid <- fresh argNam <- return $ "arg" ++ show argUid emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valUid <- fresh valNam <- return $ "val" ++ show valUid numUid <- fresh numNam <- return $ "num" ++ show numUid emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preUid <- fresh preNam <- return $ "pre" ++ show preUid emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrUid <- fresh ctrNam <- return $ "ctr" ++ show ctrUid emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #80: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #81: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #82: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFastCore book fid (App fun arg) = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupUid <- fresh dupNam <- return $ "dup" ++ show dupUid dp0Uid <- fresh dp0Nam <- return $ "dp0" ++ show dp0Uid dp1Uid <- fresh dp1Nam <- return $ "dp1" ++ show dp1Uid valUid <- fresh valNam <- return $ "val" ++ show valUid valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFastCore book fid (Mat val css) = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid retUid <- fresh retNam <- return $ "ret" ++ show retUid nu0Uid <- fresh nu0Nam <- return $ "nu0" ++ show nu0Uid nu1Uid <- fresh nu1Nam <- return $ "nu1" ++ show nu1Uid nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = reduce(" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = reduce(" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" let oprStr = case opr of OP_ADD -> "+" OP_SUB -> "-" OP_MUL -> "*" OP_DIV -> "/" OP_MOD -> "%" OP_EQ -> "==" OP_NE -> "!=" OP_LT -> "<" OP_GT -> ">" OP_LTE -> "<=" OP_GTE -> ">=" OP_AND -> "&" OP_OR -> "|" OP_XOR -> "^" OP_LSH -> "<<" OP_RSH -> ">>" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") " ++ oprStr ++ " term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #83: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #84: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #85: -- Type.hs: -- //./Type.hs// #86: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #87: module Main where #88: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #89: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #90: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #91: -- Main -- ---- #92: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #93: -- CLI Commands -- ------------ #94: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #95: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #96: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #97: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #98: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #99: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #100: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #101: -- Normalize main init <- getCPUTime #102: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #103: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #104: -- Finalize hvmFree return $ Right () #105: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #106: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #107: module HVML.Type where #108: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #109: -- Core Types -- ---------- #110: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #111: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #112: type Func = ([String], Core) #113: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #114: -- Runtime Types -- ------------- #115: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #116: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #117: type HVM = IO #118: -- C Functions -- ----------- #119: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #120: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #121: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #122: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #123: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #124: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #125: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #127: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #128: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #129: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #130: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #131: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #132: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #133: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #134: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #135: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #136: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #161: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #162: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #163: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #164: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #165: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #166: -- Constants -- --------- #167: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #168: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #169: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #170: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #171: typedef _Atomic(Term) ATerm; #172: // Runtime Types // ------------- #173: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #174: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #175: // Constants // --------- #176: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #177: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #178: #define VOID 0x00000000000000 #179: // Heap // ---- #180: Loc get_len() { return *HVM.size; } #181: u64 get_itr() { return *HVM.itrs; } #182: void set_len(Loc value) { *HVM.size = value; } #183: void set_itr(Loc value) { *HVM.itrs = value; } #184: // Terms // ------ #185: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #186: Tag term_tag(Term x) { return x & 0xFF; } #187: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #188: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #189: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #190: // u12v2 // ----- #191: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #192: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #193: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #194: // Atomics // ------- #195: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #196: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #197: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term take(Loc loc) { return swap(loc, VOID); } #199: // Allocation // ---------- #200: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #201: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #202: // Stringification // --------------- #203: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #204: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #205: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #206: // Evaluation // ---------- #207: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #208: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #209: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #210: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #211: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #212: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #213: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #214: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #215: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #216: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #218: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #219: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #220: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #221: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #222: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #223: // TODO: now, let's implement the missing OPX interactions. #224: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #225: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #226: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #227: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #228: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #229: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #230: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #231: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #232: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #233: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #234: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #235: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #236: // Runtime Memory // -------------- #237: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #238: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #239: State* hvm_get_state() { return &HVM; } #240: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #241: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #242: -- //./Type.hs// #243: module HVML.Extract where #244: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #245: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #246: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: case arity lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #247: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #248: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #249: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #250: -- //./Type.hs// #251: module HVML.Inject where #252: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #253: type InjectM a = StateT InjectState HVM a #254: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #255: emptyState :: InjectState emptyState = InjectState Map.empty [] #256: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #257: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #258: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #259: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #260: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #261: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #262: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #263: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #264: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #265: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #266: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #267: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> #268: case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

1717833ba47b6bbdd9fd25447d26f925f96d2262

HVM3 compiler WIP: up to 2400m itr/s single-core

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "(@" ++ nam ++ concat (map (\ x -> " " ++ coreToString x) arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// -- //./Show.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" arg <- parseCore return arg char ')' return $ foldl App fun args '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "(@" name <- parseName args <- many $ do closeWith ")" parseCore consume ")" return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- many $ do closeWith "=" name <- parseName1 return name skip consume "=" core <- parseCore trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () return (name, (args, core)) #32: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #33: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #34: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #35: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #36: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #37: -- Helper Parsers -- -------------- #38: consume :: String -> ParserM String consume str = spaces >> string str #39: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #40: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #41: -- Adjusting -- --------- #42: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #43: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #44: -- Errors -- ------ #45: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #46: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #47: -- //./Type.hs// #48: module HVML.Reduce where #49: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #50: import Debug.Trace #51: -- debug a b = trace a b debug a b = b #52: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #53: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #54: normal :: Book -> Term -> HVM Term normal = normalizer reduce #55: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #56: -- //./Type.hs// #57: module HVML.Compile where #58: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #59: import Debug.Trace #60: -- Compilation -- ----------- #61: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #62: type Compile = State CompileState #63: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #64: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #65: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #66: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #67: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #68: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #69: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #70: -- Full Compiler -- ------------- #71: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #72: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #73: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFullCore book fid bod (lamName ++ " + 1") emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFullCore book fid (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appName ++ " + 0") argT <- compileFullCore book fid arg (appName ++ " + 1") emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supName ++ " + 0") tm1T <- compileFullCore book fid tm1 (supName ++ " + 1") emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ "Loc " ++ dupName ++ " = alloc_node(3);" emit $ "set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileFullCore book fid val (dupName ++ " + 2") emit $ "set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFullCore book fid (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matName ++ " + 0") emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refName ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #74: -- Fast Compiler -- ------------- #75: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argUid <- fresh argNam <- return $ "arg" ++ show argUid emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #76: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #77: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valUid <- fresh valNam <- return $ "val" ++ show valUid numUid <- fresh numNam <- return $ "num" ++ show numUid emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preUid <- fresh preNam <- return $ "pre" ++ show preUid emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrUid <- fresh ctrNam <- return $ "ctr" ++ show ctrUid emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #78: -- compileFastBody book fid term ctx itr = do -- let (callFid, callArgs) = getCall term -- -- trace (coreToString term ++ " ||| " ++ show (length callArgs) ++ " " ++ show (length ctx) ++ " " ++ show callFid ++ " " ++ show fid) $ do -- if length callArgs == length ctx && callFid == fid then do -- forM_ (zip callArgs ctx) $ \ (arg, ctxVar) -> do -- argT <- compileFastCore book fid arg -- emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" -- emit $ "itrs += " ++ show (length ctx + itr + 1) ++ ";" -- emit $ "continue;" -- else do -- emit $ "itrs += " ++ show (length ctx + itr) ++ ";" -- body <- compileFastCore book fid term -- compileFastSave book fid term ctx itr -- emit $ "return " ++ body ++ ";" -- where -- getCall :: Core -> (Word64, [Core]) -- getCall = go [] where -- go ctx (App f x) = go (x:ctx) f -- go ctx (Ref _ i) = (i, ctx) -- go ctx term = (0xFFFFFFFF, ctx) #79: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #80: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #81: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #82: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFastCore book fid (App fun arg) = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupUid <- fresh dupNam <- return $ "dup" ++ show dupUid dp0Uid <- fresh dp0Nam <- return $ "dp0" ++ show dp0Uid dp1Uid <- fresh dp1Nam <- return $ "dp1" ++ show dp1Uid valUid <- fresh valNam <- return $ "val" ++ show valUid valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFastCore book fid (Mat val css) = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid retUid <- fresh retNam <- return $ "ret" ++ show retUid nu0Uid <- fresh nu0Nam <- return $ "nu0" ++ show nu0Uid nu1Uid <- fresh nu1Nam <- return $ "nu1" ++ show nu1Uid nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = reduce(" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = reduce(" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") + term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #83: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #84: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #85: -- Type.hs: -- //./Type.hs// #86: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #87: module Main where #88: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #89: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #90: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #91: -- Main -- ---- #92: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #93: -- CLI Commands -- ------------ #94: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #95: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #96: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #97: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #98: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #99: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #100: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #101: -- Normalize main init <- getCPUTime #102: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #103: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #104: -- Finalize hvmFree return $ Right () #105: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #106: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #107: -- //./Runtime.c// #108: module HVML.Type where #109: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #110: -- Core Types -- ---------- #111: -- NOTE TO AI: we're refactoring REF. Now, instead of nullary (like '@foo'), it -- will hold a list of arguments (like '(@foo A B C ...)'). As such, it is -- compiled similarly to constructors, and must allocate a space for each arg. #112: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #163: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #164: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #165: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #166: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #168: -- Constants -- --------- #169: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag: " ++ show tag #170: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #171: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #172: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #173: typedef _Atomic(Term) ATerm; #174: // Runtime Types // ------------- #175: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position u64* sbeg; // reduction stack begin ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #176: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .sbeg = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #177: // Constants // --------- #178: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #179: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #180: #define VOID 0x00000000000000 #181: // Heap // ---- #182: Loc get_len() { return *HVM.size; } #183: u64 get_itr() { return *HVM.itrs; } #184: void set_len(Loc value) { *HVM.size = value; } #185: void set_itr(Loc value) { *HVM.itrs = value; } #186: // Terms // ------ #187: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #188: Tag term_tag(Term x) { return x & 0xFF; } #189: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #190: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #191: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #192: // u12v2 // ----- #193: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #194: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #195: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #196: // Atomics // ------- #197: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #199: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #200: Term take(Loc loc) { return swap(loc, VOID); } #201: // Allocation // ---------- #202: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #203: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #204: // Stringification // --------------- #205: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #206: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #207: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #208: // Evaluation // ---------- #209: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #210: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #211: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #212: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #213: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #214: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #215: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #216: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #218: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #219: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #220: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #221: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #222: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #223: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #224: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #225: // TODO: now, let's implement the missing OPX interactions. #226: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #227: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #228: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #229: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #230: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #231: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #232: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #233: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #234: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #235: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #236: Term reduce(Term term) { //printf("reduce\n"); Term next = term; u64 back = *HVM.sbeg; *HVM.sbeg = *HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*HVM.spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*HVM.spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*HVM.spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*HVM.spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*HVM.spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*HVM.spos) == (*HVM.sbeg)) { break; } else { Term prev = HVM.sbuf[--(*HVM.spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == (*HVM.sbeg)) { //printf("retr: "); print_term(next); printf("\n"); *HVM.sbeg = back; return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } *HVM.sbeg = back; return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #237: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #238: // Runtime Memory // -------------- #239: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.sbeg = malloc(sizeof(u64)); *HVM.sbeg = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #240: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.sbeg); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #241: State* hvm_get_state() { return &HVM; } #242: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.sbeg = hvm->sbeg; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #243: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #244: -- //./Type.hs// #245: module HVML.Extract where #246: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #247: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #248: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: arity hint is lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #249: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #250: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #251: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #252: -- //./Type.hs// #253: module HVML.Inject where #254: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> #270: case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.List import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid arg) = "@" ++ nam ++ "(" ++ intercalate " " (map coreToString arg) ++ ")" coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map (\ (ar,cs) -> coreToString cs) css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: data ParserState = ParserState { parsedCtrToAri :: MS.Map String Int , parsedCtrToCid :: MS.Map String Word64 } #23: type ParserM = Parsec String ParserState #24: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of -- '@' -> parseRef '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" parseCore char ')' return $ foldl App fun args '@' -> parseRef '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads (filter (/= '_') name) of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #25: parseRef :: ParserM Core parseRef = do consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseCore consume ")" return args return $ Ref name 0 args #26: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do cids <- parsedCtrToCid <$> getState case MS.lookup nam cids of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #27: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName cids <- parsedCtrToCid <$> getState aris <- parsedCtrToAri <$> getState ari <- case MS.lookup name aris of Just ari -> return ari Nothing -> return (-1) cid <- case MS.lookup name cids of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, (ari, cas)) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #28: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #29: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #30: parseName1 :: ParserM String parseName1 = skip >> many1 (alphaNum <|> char '_') #31: -- parseDef :: ParserM (String, ([String], Core)) -- parseDef = do -- try $ do -- skip -- consume "@" -- name <- parseName -- args <- many $ do -- closeWith "=" -- name <- parseName1 -- return name -- skip -- consume "=" -- core <- parseCore -- trace ("PARSED: " ++ name ++ " " ++ show args ++ " = " ++ coreToString core) $ return () -- return (name, (args, core)) #32: -- TODO: update the syntax of definitions, from '@foo x y z = body' to '@foo(x,y,z) = body'. update the trace too parseDef :: ParserM (String, ([String], Core)) parseDef = do try $ do skip consume "@" name <- parseName args <- option [] $ do try $ string "(" args <- many $ do closeWith ")" parseName consume ")" return args skip consume "=" core <- parseCore -- trace ("PARSED: " ++ name ++ "(" ++ intercalate "," args ++ ") = " ++ coreToString core) $ return () return (name, (args, core)) #33: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let ctrCids = zip (map fst constructors) [0..] let ctrAris = zip (map fst constructors) (map (fromIntegral . length . snd) constructors) modifyState (\s -> s { parsedCtrToCid = MS.union (MS.fromList ctrCids) (parsedCtrToCid s), parsedCtrToAri = MS.union (MS.fromList ctrAris) (parsedCtrToAri s) }) #34: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #35: parseBook :: ParserM [(String, ([String], Core))] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #36: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 [] #37: doParseBook :: String -> IO Book doParseBook code = case runParser parseBookWithState (ParserState MS.empty MS.empty) "" code of Right (defs, st) -> do return $ createBook defs (parsedCtrToCid st) (parsedCtrToAri st) Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty MS.empty MS.empty where parseBookWithState :: ParserM ([(String, ([String], Core))], ParserState) parseBookWithState = do defs <- parseBook st <- getState return (defs, st) #38: -- Helper Parsers -- -------------- #39: consume :: String -> ParserM String consume str = spaces >> string str #40: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #41: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #42: -- Adjusting -- --------- #43: createBook :: [(String, ([String], Core))] -> MS.Map String Word64 -> MS.Map String Int -> Book createBook defs ctrToCid ctrToAri = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' idToFunc' = MS.fromList $ map (\ (name, (args, core)) -> (nameToId' MS.! name, (args, decorateFnIds nameToId' core))) defs in Book idToFunc' idToName' nameToId' ctrToAri ctrToCid #44: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ arg -> Ref nam (fids MS.! nam) (map (decorateFnIds fids) arg) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x css -> Mat (decorateFnIds fids x) (map (\ (ar,cs) -> (ar, decorateFnIds fids cs)) css) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #45: -- Errors -- ------ #46: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #47: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #48: -- //./Type.hs// #49: module HVML.Reduce where #50: import Control.Monad (when) import Data.Word import HVML.Inject import HVML.Show import HVML.Type import System.Exit import qualified Data.Map.Strict as MS #51: import Debug.Trace #52: -- debug a b = trace a b debug a b = b #53: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = u12v2X lab let ari = u12v2Y lab case MS.lookup fid (idToFunc book) of Just (nams, core) -> do incItr when (length nams /= fromIntegral ari) $ do putStrLn $ "RUNTIME_ERROR: arity mismatch on call to '@" ++ idToName book MS.! fid ++ "'." exitFailure args <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0 .. ari - 1] core <- doInjectCore book core $ zip nams args reduce book core Nothing -> return term otherwise -> do return term #54: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #55: normal :: Book -> Term -> HVM Term normal = normalizer reduce #56: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #57: -- //./Type.hs// #58: module HVML.Compile where #59: import Control.Monad (forM_, forM) import Control.Monad.State import Data.List import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #60: import Debug.Trace #61: -- Compilation -- ----------- #62: data CompileState = CompileState { next :: Word64 , tabs :: Int , bins :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #63: type Compile = State CompileState #64: compile :: Book -> Word64 -> String compile book fid = let full = compileWith compileFull book fid in let fast = compileWith compileFast book fid in let slow = compileWith compileSlow book fid in if "<ERR>" `isInfixOf` fast then unlines [ full , slow ] else unlines [ full , fast ] #65: -- Compiles a function using either Fast-Mode or Full-Mode compileWith :: (Book -> Word64 -> Core -> [String] -> Compile ()) -> Book -> Word64 -> String compileWith cmp book fid = let args = fst (idToFunc book MS.! fid) in let core = snd (idToFunc book MS.! fid) in let state = CompileState 0 0 MS.empty [] [] in let result = runState (cmp book fid core args) state in unlines $ reverse $ code (snd result) #66: emit :: String -> Compile () emit line = modify $ \st -> st { code = (replicate (tabs st * 2) ' ' ++ line) : code st } #67: tabInc :: Compile () tabInc = modify $ \st -> st { tabs = tabs st + 1 } #68: tabDec :: Compile () tabDec = modify $ \st -> st { tabs = tabs st - 1 } #69: bind :: String -> String -> Compile () bind var host = modify $ \st -> st { bins = MS.insert var host (bins st) } #70: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #71: -- Full Compiler -- ------------- #72: compileFull :: Book -> Word64 -> Core -> [String] -> Compile () compileFull book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_t(Term ref) {" tabInc forM_ (zip [0..] args) $ \(i, arg) -> do bind arg $ "got(term_loc(ref) + " ++ show i ++ ")" result <- compileFullCore book fid core "root" st <- get forM_ (vars st) $ \ (var,host) -> do let varTerm = MS.findWithDefault "" var (bins st) emit $ "set(" ++ host ++ ", " ++ varTerm ++ ");" emit $ "return " ++ result ++ ";" tabDec emit "}" #73: compileFullVar :: String -> String -> Compile String compileFullVar var host = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do modify $ \s -> s { vars = (var, host) : vars s } return "0" #74: compileFullCore :: Book -> Word64 -> Core -> String -> Compile String compileFullCore book fid Era _ = return $ "term_new(ERA, 0, 0)" compileFullCore book fid (Var name) host = do compileFullVar name host compileFullCore book fid (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFullCore book fid bod (lamName ++ " + 1") emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFullCore book fid (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFullCore book fid fun (appName ++ " + 0") argT <- compileFullCore book fid arg (appName ++ " + 1") emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFullCore book fid (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFullCore book fid tm0 (supName ++ " + 0") tm1T <- compileFullCore book fid tm1 (supName ++ " + 1") emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFullCore book fid (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ "Loc " ++ dupName ++ " = alloc_node(3);" emit $ "set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileFullCore book fid val (dupName ++ " + 2") emit $ "set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileFullCore book fid bod host return bodT compileFullCore book fid (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFullCore book fid fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFullCore book fid (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFullCore book fid val (matName ++ " + 0") emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFullCore book fid cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFullCore book fid (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFullCore book fid (Op2 opr nu0 nu1) host = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid emit $ "Loc " ++ opxNam ++ " = alloc_node(2);" nu0T <- compileFullCore book fid nu0 (opxNam ++ " + 0") nu1T <- compileFullCore book fid nu1 (opxNam ++ " + 1") emit $ "set(" ++ opxNam ++ " + 0, " ++ nu0T ++ ");" emit $ "set(" ++ opxNam ++ " + 1, " ++ nu1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ")" compileFullCore book fid (Ref rNam rFid rArg) host = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFullCore book fid arg (refName ++ " + " ++ show i)) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #75: -- Fast Compiler -- ------------- #76: -- Compiles a function using Fast-Mode compileFast :: Book -> Word64 -> Core -> [String] -> Compile () compileFast book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" tabInc emit "u64 itrs = 0;" args <- forM (zip [0..] args) $ \ (i, arg) -> do argUid <- fresh argNam <- return $ "arg" ++ show argUid emit $ "Term " ++ argNam ++ " = got(term_loc(ref) + " ++ show i ++ ");" bind arg argNam return argNam compileFastArgs book fid core args tabDec emit "}" #77: -- Compiles a fast function's argument list compileFastArgs :: Book -> Word64 -> Core -> [String] -> Compile () compileFastArgs book fid body ctx = do emit $ "while (1) {" tabInc compileFastBody book fid body ctx 0 tabDec emit $ "}" #78: -- Compiles a fast function body (pattern-matching) compileFastBody :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastBody book fid term@(Mat val css) ctx itr = do valT <- compileFastCore book fid val valUid <- fresh valNam <- return $ "val" ++ show valUid numUid <- fresh numNam <- return $ "num" ++ show numUid emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" let isNumeric = length css > 0 && fst (css !! 0) == -1 -- Numeric Pattern-Matching if isNumeric then do emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "u32 " ++ numNam ++ " = term_loc(" ++ valNam ++ ");" emit $ "switch (" ++ numNam ++ ") {" tabInc forM_ (zip [0..] css) $ \ (i, (_,cs)) -> do if i < length css - 1 then do emit $ "case " ++ show i ++ ": {" tabInc compileFastBody book fid cs ctx (itr + 1) emit $ "break;" tabDec emit $ "}" else do emit $ "default: {" tabInc preUid <- fresh preNam <- return $ "pre" ++ show preUid emit $ "Term " ++ preNam ++ " = " ++ "term_new(W32, 0, "++numNam++" - "++show (length css - 1)++");" compileFastApps book fid cs [preNam] ctx (itr + 1 + 1) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" -- Constructor Pattern-Matching else do emit $ "if (term_tag(" ++ valNam ++ ") == CTR) {" tabInc emit $ "switch (u12v2_x(term_lab(" ++ valNam ++ "))) {" tabInc forM_ (zip [0..] css) $ \ (i, (ar,cs)) -> do emit $ "case " ++ show i ++ ": {" tabInc args <- if ar == 0 then return [] else forM [0..ar-1] $ \k -> do ctrUid <- fresh ctrNam <- return $ "ctr" ++ show ctrUid emit $ "Term " ++ ctrNam ++ " = got(term_loc(" ++ valNam ++ ") + " ++ show k ++ ");" return ctrNam compileFastApps book fid cs args ctx (itr + 1 + fromIntegral ar) emit $ "break;" tabDec emit $ "}" tabDec emit $ "}" tabDec emit $ "}" compileFastUndo book fid term ctx itr compileFastBody book fid term@(Ref fNam fFid fArg) ctx itr | fFid == fid = do forM_ (zip fArg ctx) $ \ (arg, ctxVar) -> do argT <- compileFastCore book fid arg emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" emit $ "itrs += " ++ show (itr + 1) ++ ";" emit $ "continue;" compileFastBody book fid term ctx itr = do emit $ "itrs += " ++ show (itr) ++ ";" body <- compileFastCore book fid term compileFastSave book fid term ctx itr emit $ "return " ++ body ++ ";" #79: -- compileFastBody book fid term ctx itr = do -- let (callFid, callArgs) = getCall term -- -- trace (coreToString term ++ " ||| " ++ show (length callArgs) ++ " " ++ show (length ctx) ++ " " ++ show callFid ++ " " ++ show fid) $ do -- if length callArgs == length ctx && callFid == fid then do -- forM_ (zip callArgs ctx) $ \ (arg, ctxVar) -> do -- argT <- compileFastCore book fid arg -- emit $ "" ++ ctxVar ++ " = " ++ argT ++ ";" -- emit $ "itrs += " ++ show (length ctx + itr + 1) ++ ";" -- emit $ "continue;" -- else do -- emit $ "itrs += " ++ show (length ctx + itr) ++ ";" -- body <- compileFastCore book fid term -- compileFastSave book fid term ctx itr -- emit $ "return " ++ body ++ ";" -- where -- getCall :: Core -> (Word64, [Core]) -- getCall = go [] where -- go ctx (App f x) = go (x:ctx) f -- go ctx (Ref _ i) = (i, ctx) -- go ctx term = (0xFFFFFFFF, ctx) #80: -- ... compileFastApps :: Book -> Word64 -> Core -> [String] -> [String] -> Int -> Compile () compileFastApps book fid (Lam pvar pbod) (arg : args) ctx itr = do bind pvar $ arg compileFastApps book fid pbod args ctx itr compileFastApps book fid term [] ctx itr = compileFastBody book fid term ctx itr compileFastApps book fid term args ctx itr = error "TODO" #81: -- Falls back from fast mode to full mode compileFastUndo :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastUndo book fid term ctx itr = do forM_ (zip [0..] ctx) $ \ (i, arg) -> do emit $ "set(term_loc(ref) + "++show i++", " ++ arg ++ ");" emit $ "return " ++ idToName book MS.! fid ++ "_t(ref);" #82: -- Completes a fast mode call compileFastSave :: Book -> Word64 -> Core -> [String] -> Int -> Compile () compileFastSave book fid term ctx itr = do emit $ "*HVM.itrs += itrs;" #83: -- Compiles a core term in fast more compileFastCore :: Book -> Word64 -> Core -> Compile String compileFastCore book fid Era = return $ "term_new(ERA, 0, 0)" compileFastCore book fid (Var name) = do compileFastVar name compileFastCore book fid (Lam var bod) = do uid <- fresh let lamName = "lam" ++ show uid emit $ "Loc " ++ lamName ++ " = alloc_node(2);" emit $ "set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileFastCore book fid bod emit $ "set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileFastCore book fid (App fun arg) = do uid <- fresh let appName = "app" ++ show uid emit $ "Loc " ++ appName ++ " = alloc_node(2);" funT <- compileFastCore book fid fun argT <- compileFastCore book fid arg emit $ "set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ "set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileFastCore book fid (Sup lab tm0 tm1) = do uid <- fresh let supName = "sup" ++ show uid emit $ "Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileFastCore book fid tm0 tm1T <- compileFastCore book fid tm1 emit $ "set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ "set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileFastCore book fid (Dup lab dp0 dp1 val bod) = do dupUid <- fresh dupNam <- return $ "dup" ++ show dupUid dp0Uid <- fresh dp0Nam <- return $ "dp0" ++ show dp0Uid dp1Uid <- fresh dp1Nam <- return $ "dp1" ++ show dp1Uid valUid <- fresh valNam <- return $ "val" ++ show valUid valT <- compileFastCore book fid val emit $ "Term " ++ valNam ++ " = reduce(" ++ valT ++ ");" emit $ "Term " ++ dp0Nam ++ ";" emit $ "Term " ++ dp1Nam ++ ";" emit $ "if (term_tag(" ++ valNam ++ ") == W32) {" tabInc emit $ "itrs += 1;" emit $ dp0Nam ++ " = " ++ valNam ++ ";" emit $ dp1Nam ++ " = " ++ valNam ++ ";" tabDec emit $ "} else {" tabInc emit $ "Loc " ++ dupNam ++ " = alloc_node(3);" emit $ "set(" ++ dupNam ++ " + 0, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 1, term_new(SUB, 0, 0));" emit $ "set(" ++ dupNam ++ " + 2, " ++ valNam ++ ");" emit $ dp0Nam ++ " = term_new(DP0, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" emit $ dp1Nam ++ " = term_new(DP1, " ++ show lab ++ ", " ++ dupNam ++ " + 0);" tabDec emit $ "}" bind dp0 dp0Nam bind dp1 dp1Nam compileFastCore book fid bod compileFastCore book fid (Ctr cid fds) = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ "Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileFastCore book fid fd) (zip [0..] fds) sequence_ [emit $ "set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileFastCore book fid (Mat val css) = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ "Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileFastCore book fid val emit $ "set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,(_,cs)) -> compileFastCore book fid cs) (zip [0..] css) sequence_ [emit $ "set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileFastCore book fid (U32 val) = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileFastCore book fid (Op2 opr nu0 nu1) = do opxUid <- fresh opxNam <- return $ "opx" ++ show opxUid retUid <- fresh retNam <- return $ "ret" ++ show retUid nu0Uid <- fresh nu0Nam <- return $ "nu0" ++ show nu0Uid nu1Uid <- fresh nu1Nam <- return $ "nu1" ++ show nu1Uid nu0T <- compileFastCore book fid nu0 nu1T <- compileFastCore book fid nu1 emit $ "Term " ++ nu0Nam ++ " = reduce(" ++ nu0T ++ ");" emit $ "Term " ++ nu1Nam ++ " = reduce(" ++ nu1T ++ ");" emit $ "Term " ++ retNam ++ ";" emit $ "if (term_tag(" ++ nu0Nam ++ ") == W32 && term_tag(" ++ nu1Nam ++ ") == W32) {" emit $ " itrs += 2;" emit $ " " ++ retNam ++ " = term_new(W32, 0, term_loc(" ++ nu0Nam ++ ") + term_loc(" ++ nu1Nam ++ "));" emit $ "} else {" emit $ " Loc " ++ opxNam ++ " = alloc_node(2);" emit $ " set(" ++ opxNam ++ " + 0, " ++ nu0Nam ++ ");" emit $ " set(" ++ opxNam ++ " + 1, " ++ nu1Nam ++ ");" emit $ " " ++ retNam ++ " = term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxNam ++ ");" emit $ "}" return $ retNam compileFastCore book fid (Ref rNam rFid rArg) = do uid <- fresh let refName = "ref" ++ show uid let arity = length rArg emit $ "Loc " ++ refName ++ " = alloc_node(" ++ show arity ++ ");" argsT <- mapM (\ (i,arg) -> compileFastCore book fid arg) (zip [0..] rArg) sequence_ [emit $ "set(" ++ refName ++ " + " ++ show i ++ ", " ++ argT ++ ");" | (i,argT) <- zip [0..] argsT] return $ "term_new(REF, u12v2_new(" ++ show rFid ++ ", " ++ show arity ++ "), " ++ refName ++ ")" #84: -- Compiles a variable in fast mode compileFastVar :: String -> Compile String compileFastVar var = do bins <- gets bins case MS.lookup var bins of Just entry -> do return entry Nothing -> do return "<ERR>" #85: -- Compiles a function using Fast-Mode compileSlow :: Book -> Word64 -> Core -> [String] -> Compile () compileSlow book fid core args = do emit $ "Term " ++ idToName book MS.! fid ++ "_f(Term ref) {" emit $ " return " ++ idToName book MS.! fid ++ "_t(ref);" emit $ "}" ./Main.hs #86: -- Type.hs: -- //./Type.hs// #87: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #88: module Main where #89: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import Text.Printf import qualified Data.Map.Strict as MS #90: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #91: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #92: -- Main -- ---- #93: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #94: -- CLI Commands -- ------------ #95: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #96: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #97: -- Create the C file content let funcs = map (\ (fid, _) -> compile book fid) (MS.toList (idToFunc book)) let mainC = unlines $ [runtime_c] ++ funcs ++ [genMain book] #98: -- Compile to native when compiled $ do -- Write the C file writeFile "./.main.c" mainC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .main.c -o .main.so" -- Load the dynamic library bookLib <- dlopen "./.main.so" [RTLD_NOW] #99: -- Remove both generated files callCommand "rm .main.so" -- Register compiled functions forM_ (MS.keys (idToFunc book)) $ \ fid -> do funPtr <- dlsym bookLib (idToName book MS.! fid ++ "_f") hvmDefine fid funPtr #100: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] #101: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #102: -- Normalize main init <- getCPUTime #103: root <- doInjectCore book (Ref "main" (nameToId book MS.! "main") []) [] -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #104: -- Show stats when showStats $ do end <- getCPUTime itrs <- getItr size <- getLen let time = fromIntegral (end - init) / (10^12) :: Double let mips = (fromIntegral itrs / 1000000.0) / time printf "WORK: %llu interactions\n" itrs printf "TIME: %.3f seconds\n" time printf "SIZE: %llu nodes\n" size printf "PERF: %.3f MIPS\n" mips return () #105: -- Finalize hvmFree return $ Right () #106: genMain :: Book -> String genMain book = let mainFid = nameToId book MS.! "main" registerFuncs = unlines [" hvm_define(" ++ show fid ++ ", " ++ idToName book MS.! fid ++ "_f);" | fid <- MS.keys (idToFunc book)] in unlines [ "int main() {" , " hvm_init();" , registerFuncs , " clock_t start = clock();" , " Term root = term_new(REF, u12v2_new("++show mainFid++",0), 0);" , " normal(root);" , " double time = (double)(clock() - start) / CLOCKS_PER_SEC * 1000;" , " printf(\"WORK: %llu interactions\\n\", get_itr());" , " printf(\"TIME: %.3fs seconds\\n\", time / 1000.0);" , " printf(\"SIZE: %u nodes\\n\", get_len());" , " printf(\"PERF: %.3f MIPS\\n\", (get_itr() / 1000000.0) / (time / 1000.0));" , " hvm_free();" , " return 0;" , "}" ] #107: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #108: module HVML.Type where #109: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #110: -- Core Types -- ---------- #111: -- NOTE TO AI: we're refactoring REF. Now, instead of nullary (like '@foo'), it -- will hold a list of arguments (like '(@foo A B C ...)'). As such, it is -- compiled similarly to constructors, and must allocate a space for each arg. #112: data Core = Var String | Ref String Word64 [Core] | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [(Int,Core)] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #113: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #114: type Func = ([String], Core) #115: data Book = Book { idToFunc :: MS.Map Word64 Func , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 , ctrToAri :: MS.Map String Int , ctrToCid :: MS.Map String Word64 } deriving (Show, Eq) #116: -- Runtime Types -- ------------- #117: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #118: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #119: type HVM = IO #120: -- C Functions -- ----------- #121: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #122: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #123: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #124: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #125: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #126: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #127: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #128: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #129: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #130: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #131: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #132: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #133: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #134: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #135: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #136: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #141: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #142: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #143: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #144: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #145: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #146: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #147: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #148: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #149: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #150: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #151: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #152: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #153: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #154: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #155: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #156: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #157: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #158: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #159: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #160: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #161: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #162: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #163: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #164: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #165: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #166: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #167: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #168: -- Constants -- --------- #169: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = SUB tagT 0x04 = REF tagT 0x05 = APP tagT 0x06 = MAT tagT 0x07 = OPX tagT 0x08 = OPY tagT 0x09 = ERA tagT 0x0A = LAM tagT 0x0B = SUP tagT 0x0C = CTR tagT 0x0D = W32 tagT tag = error $ "unknown tag: " ++ show tag #170: _DP0_, _DP1_, _VAR_, _SUB_, _REF_, _APP_, _MAT_, _OPX_, _OPY_, _ERA_, _LAM_, _SUP_, _CTR_, _W32_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _SUB_ = 0x03 _REF_ = 0x04 _APP_ = 0x05 _MAT_ = 0x06 _OPX_ = 0x07 _OPY_ = 0x08 _ERA_ = 0x09 _LAM_ = 0x0A _SUP_ = 0x0B _CTR_ = 0x0C _W32_ = 0x0D ./Runtime.c #171: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #172: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #173: typedef _Atomic(Term) ATerm; #174: // Runtime Types // ------------- #175: // Global State Type typedef struct { Term* sbuf; // reduction stack buffer u64* spos; // reduction stack position ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(Term); // functions } State; #176: // Global State Value static State HVM = { .sbuf = NULL, .spos = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #177: // Constants // --------- #178: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define SUB 0x03 #define REF 0x04 #define APP 0x05 #define MAT 0x06 #define OPX 0x07 #define OPY 0x08 #define ERA 0x09 #define LAM 0x0A #define SUP 0x0B #define CTR 0x0C #define W32 0x0D #179: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #180: #define VOID 0x00000000000000 #181: // Heap // ---- #182: Loc get_len() { return *HVM.size; } #183: u64 get_itr() { return *HVM.itrs; } #184: void set_len(Loc value) { *HVM.size = value; } #185: void set_itr(Loc value) { *HVM.itrs = value; } #186: // Terms // ------ #187: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #188: Tag term_tag(Term x) { return x & 0xFF; } #189: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #190: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #191: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #192: // u12v2 // ----- #193: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #194: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #195: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #196: // Atomics // ------- #197: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #198: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #199: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #200: Term take(Loc loc) { return swap(loc, VOID); } #201: // Allocation // ---------- #202: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #203: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #204: // Stringification // --------------- #205: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; case W32: printf("W32"); break; case OPX: printf("OPX"); break; case OPY: printf("OPY"); break; default : printf("???"); break; } } #206: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #207: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #208: // Evaluation // ---------- #209: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { //printf("call %d %p\n", term_loc(ref), HVM.book[term_loc(ref)]); inc_itr(); return HVM.book[u12v2_x(term_lab(ref))](ref); } #210: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #211: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #212: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #213: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #214: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #215: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #216: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #217: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #218: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #219: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #220: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #221: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #222: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #223: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #224: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #225: // TODO: now, let's implement the missing OPX interactions. #226: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #227: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #228: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #229: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #230: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #231: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #232: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #233: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #234: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #235: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #236: Term reduce(Term term) { //printf("reduce\n"); if (term_tag(term) >= ERA) return term; Term next = term; u64 stop = *HVM.spos; u64* spos = HVM.spos; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.sbuf[(*spos)++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPX: { HVM.sbuf[(*spos)++] = next; next = got(loc + 0); continue; } case OPY: { HVM.sbuf[(*spos)++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); // TODO continue; } default: { if ((*spos) == stop) { break; } else { Term prev = HVM.sbuf[--(*spos)]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if ((*HVM.spos) == stop) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.sbuf[--(*HVM.spos)]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.sbuf[0]; } } printf("retr: ERR\n"); return 0; } #237: Term normal(Term term) { Term wnf = reduce(term); Tag tag = term_tag(wnf); Lab lab = term_lab(wnf); Loc loc = term_loc(wnf); switch (tag) { case APP: { Term fun = got(loc + 0); Term arg = got(loc + 1); fun = normal(fun); arg = normal(arg); set(loc + 0, fun); set(loc + 1, arg); return wnf; } case LAM: { Term bod = got(loc + 1); bod = normal(bod); set(loc + 1, bod); return wnf; } case SUP: { Term tm0 = got(loc + 0); Term tm1 = got(loc + 1); tm0 = normal(tm0); tm1 = normal(tm1); set(loc + 0, tm0); set(loc + 1, tm1); return wnf; } case DP0: case DP1: { Term val = got(loc + 2); val = normal(val); set(loc + 2, val); return wnf; } case CTR: { u64 cid = u12v2_x(lab); u64 ari = u12v2_y(lab); for (u64 i = 0; i < ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } case MAT: { u64 ari = lab; for (u64 i = 0; i <= ari; i++) { Term arg = got(loc + i); arg = normal(arg); set(loc + i, arg); } return wnf; } default: return wnf; } } #238: // Runtime Memory // -------------- #239: void hvm_init() { // FIXME: use mmap instead HVM.sbuf = malloc((1ULL << 32) * sizeof(Term)); HVM.spos = malloc(sizeof(u64)); *HVM.spos = 0; HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #240: void hvm_free() { free(HVM.sbuf); free(HVM.spos); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #241: State* hvm_get_state() { return &HVM; } #242: void hvm_set_state(State* hvm) { HVM.sbuf = hvm->sbuf; HVM.spos = hvm->spos; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #243: void hvm_define(u64 fid, Term (*func)()) { //printf("defined %llu %p\n", fid, func); HVM.book[fid] = func; } ./Extract.hs #244: -- //./Type.hs// #245: module HVML.Extract where #246: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import Data.Word import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #247: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #248: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let len = termLab term val <- lift $ got (loc + 0) css <- if len == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..len-1] val0 <- extractCore val css0 <- mapM extractCore css css1 <- mapM (\ cs -> return (0, cs)) css0 -- NOTE: arity hint is lost on extraction return $ Mat val0 css1 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term let lab = termLab term let fid = u12v2X lab let ari = u12v2Y lab arg <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] arg <- mapM extractCore arg return $ Ref "?" fid arg _ -> return Era #249: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #250: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #251: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #252: -- //./Type.hs// #253: module HVML.Inject where #254: import Control.Monad (foldM) import Control.Monad (forM_) import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid arg) loc = do -- lift $ set loc (termNew _REF_ 0 fid) let arity = length arg ref <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book x (ref + i) | (i,x) <- zip [0..] arg] lift $ set loc (termNew _REF_ (u12v2New fid (fromIntegral arity)) ref) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book (snd bod) (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> [(String, Term)] -> HVM Term doInjectCore book core initialArgs = do (_, state) <- runStateT (injectCore book core 0) (emptyState { args = Map.fromList initialArgs }) forM_ (vars state) $ \(name, loc) -> #270: case Map.lookup name (args state) of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name got 0

cdf69ae72e117ac84037da1ea0d2a5e1ccdb1aaa

named constructors and fixes

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// -- //./Show.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do notFollowedBy (char ')') arg <- parseCore return arg char ')' return $ foldl App fun args '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #23: parseOper :: Oper -> Parser Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #24: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #25: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore -- trace ("parsed " ++ coreToString core) $ return (name, core) #26: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #27: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #28: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #29: -- Helper Parsers -- -------------- #30: consume :: String -> Parser String consume str = spaces >> string str #31: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #32: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #33: -- Adjusting -- --------- #34: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #35: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #36: -- Errors -- ------ #37: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #38: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #39: -- //./Type.hs// -- //./Runtime.c// #40: module HVML.Reduce where #41: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #42: import Debug.Trace #43: -- debug a b = trace a b debug a b = b #44: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #45: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #46: normal :: Book -> Term -> HVM Term normal = normalizer reduce #47: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #48: -- //./Type.hs// -- //./Inject.hs// #49: module HVML.Compile where #50: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #51: -- Compilation -- ----------- #52: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #53: type Compile = State CompileState #54: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #55: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #56: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #57: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #58: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #59: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ " Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileCore book fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ " set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileCore book (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ " Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileCore book val (matName ++ " + 0") emit $ " set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,cs) -> compileCore book cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ " set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileCore book (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileCore book (Op2 opr nm0 nm1) host = do uid <- fresh let opxName = "opx" ++ show uid emit $ " Loc " ++ opxName ++ " = alloc_node(2);" nm0T <- compileCore book nm0 (opxName ++ " + 0") nm1T <- compileCore book nm1 (opxName ++ " + 1") emit $ " set(" ++ opxName ++ " + 0, " ++ nm0T ++ ");" emit $ " set(" ++ opxName ++ " + 1, " ++ nm1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxName ++ ")" compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #60: -- Type.hs: -- //./Type.hs// #61: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #62: module Main where #63: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #64: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #65: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #66: -- Main -- ---- #67: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #68: -- CLI Commands -- ------------ #69: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #70: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #71: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #72: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #73: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #74: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #75: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #76: -- Normalize main init <- getCPUTime #77: root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #78: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #79: -- Finalize hvmFree return $ Right () #80: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #81: -- //./Runtime.c// #82: module HVML.Type where #83: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #84: -- Core Types -- ---------- #85: -- NOTE TO AI: we're now adding the uint32 type, including: -- - U32: uint32 value, like '42' -- - OPX: uint32 binary operation, like 'add', 'mul', etc. -- Your goal is to add the uint32 funcionality to each file. #86: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #87: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #88: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #89: -- Runtime Types -- ------------- #90: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #91: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #92: type HVM = IO #93: -- C Functions -- ----------- #94: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #95: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #96: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #97: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #98: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #99: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #100: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #101: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #102: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #103: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #104: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #105: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #106: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #107: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #108: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #109: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #110: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #111: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #112: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #113: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #114: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #115: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #116: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #117: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #118: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #119: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #120: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #121: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #122: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #123: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #124: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #125: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #126: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #127: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #128: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #129: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #130: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #131: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #132: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #133: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #134: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #135: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #136: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #137: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #138: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #139: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #140: -- Constants -- --------- #141: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag: " ++ show tag #142: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #143: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #144: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #145: typedef _Atomic(Term) ATerm; #146: // Runtime Types // ------------- #147: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #148: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #149: // Constants // --------- #150: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #151: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #152: #define VOID 0x00000000000000 #153: // Heap // ---- #154: Loc get_len() { return *HVM.size; } #155: Loc get_itr() { return *HVM.itrs; } #156: void set_len(Loc value) { *HVM.size = value; } #157: void set_itr(Loc value) { *HVM.itrs = value; } #158: // Terms // ------ #159: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #160: Tag term_tag(Term x) { return x & 0xFF; } #161: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #162: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #163: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #164: // u12v2 // ----- #165: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #166: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #167: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #168: // Atomics // ------- #169: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #170: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #171: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #172: Term take(Loc loc) { return swap(loc, VOID); } #173: // Allocation // ---------- #174: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #175: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #176: // Stringification // --------------- #177: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #178: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #179: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #180: // Evaluation // ---------- #181: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #182: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #183: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #184: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #185: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #186: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #187: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #188: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #189: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #190: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #191: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #192: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #193: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #194: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #195: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #196: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #197: // TODO: now, let's implement the missing OPX interactions. #198: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #199: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #200: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #201: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #202: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #203: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #204: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #205: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #206: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #207: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #208: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPX: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPY: { HVM.path[spos++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #209: // Runtime Memory // -------------- #210: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #211: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #212: State* hvm_get_state() { return &HVM; } #213: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #214: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #215: // Main // ---- #216: //#include "book.c" #217: //int main() { //hvm_init(); //inject_P24(); #218: //clock_t start = clock(); #219: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #220: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #221: //hvm_free(); //return 0; //} ./Extract.hs #222: -- //./Type.hs// #223: module HVML.Extract where #224: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #225: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #226: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let ari = termLab term val <- lift $ got (loc + 0) css <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..ari-1] val0 <- extractCore val css0 <- mapM extractCore css return $ Mat val0 css0 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term return $ Ref "?" loc _ -> return Era #227: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #228: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #229: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #230: -- //./Type.hs// #231: module HVML.Inject where #232: -- import Control.Monad (foldM) -- import Control.Monad.State -- import Data.Word -- import HVML.Type -- import qualified Data.IntMap.Strict as IM #233: -- type InjectM a = StateT (IM.IntMap (Maybe Term)) HVM a #234: -- injectCore :: Book -> Core -> Loc -> InjectM () -- injectCore _ Era loc = do -- lift $ set loc (termNew _ERA_ 0 0) #235: -- injectCore book (Lam vr0 bod) loc = do -- lam <- lift $ allocNode 2 -- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) -- injectCore book bod (lam + 1) -- lift $ set loc (termNew _LAM_ 0 lam) #236: -- injectCore book (App fun arg) loc = do -- app <- lift $ allocNode 2 -- injectCore book fun (app + 0) -- injectCore book arg (app + 1) -- lift $ set loc (termNew _APP_ 0 app) #237: -- injectCore book (Sup lab tm0 tm1) loc = do -- sup <- lift $ allocNode 2 -- injectCore book tm0 (sup + 0) -- injectCore book tm1 (sup + 1) -- lift $ set loc (termNew _SUP_ lab sup) #238: -- injectCore book (Dup lab dp0 dp1 val bod) loc = do -- dup <- lift $ allocNode 3 -- injectBind dp0 (termNew _DP0_ lab dup) -- injectBind dp1 (termNew _DP1_ lab dup) -- injectCore book val (dup + 2) -- injectCore book bod loc #239: -- injectCore book (Ref nam fid) loc = do -- lift $ set loc (termNew _REF_ 0 fid) #240: -- injectCore book (Ctr cid fds) loc = do -- let arity = length fds -- ctr <- lift $ allocNode (fromIntegral arity) -- sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] -- lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #241: -- injectCore book (Mat val css) loc = do -- mat <- lift $ allocNode (1 + fromIntegral (length css)) -- injectCore book val (mat + 0) -- sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] -- lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #242: -- injectCore book (U32 val) loc = do -- lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #243: -- injectCore book (Op2 opr nm0 nm1) loc = do -- opx <- lift $ allocNode 2 -- injectCore book nm0 (opx + 0) -- injectCore book nm1 (opx + 1) -- lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #244: -- injectCore _ (Var uid) loc = do -- let namHash = hash uid -- vars <- get -- case IM.lookup namHash vars of -- Nothing -> put $ IM.insert namHash (Just loc) vars -- Just mOldVar -> case mOldVar of -- Nothing -> put $ IM.insert namHash (Just loc) vars -- Just oldVar -> do -- lift $ set loc oldVar -- put $ IM.insert namHash (Just loc) vars -- where -- hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #245: -- injectBind :: String -> Term -> InjectM () -- injectBind nam var = do -- let subKey = termKey var -- let namHash = hash nam -- vars <- get -- case IM.lookup namHash vars of -- Nothing -> do -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- Just mOldVar -> case mOldVar of -- Nothing -> do -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- Just oldVar -> do -- lift $ set oldVar var -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- where -- hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #246: -- doInjectCore :: Book -> Core -> HVM Term -- doInjectCore book core = do -- evalStateT (injectCore book core 0) IM.empty -- got 0 #247: -- TODO: refactor this to use a similar algorithm to Compile.hs -- for handling variables. that is, we should keep a map of args, -- and a list of vars found. and we should only set the variables -- AFTER injectCore has fully returned. -- remember: we should keep two states: -- args : var_name => binder_host -- vars : [(var_name, var_host)] -- do you understand the assignment? answer below in english #248: -- Yes, I understand the assignment. The goal is to refactor the variable handling in injectCore to: #249: -- 1. Use two separate state components: -- - args: A map from variable names to their binder locations (where variables are bound) -- - vars: A list of tuples containing variable names and their usage locations #250: -- 2. Change the algorithm to: -- - First traverse the term collecting all variable usages without setting them -- - Only after the full traversal is complete, go through the vars list and set the appropriate references #251: -- This approach would be more similar to Compile.hs and would handle variable scoping more cleanly by separating the collection of variable information from the actual setting of references in memory. #252: -- The key difference from the current implementation is that variable references would not be set immediately during traversal, but rather collected and processed in a second pass after the full term structure is built. #253: -- yes. remember: we always set the LAM binder (lam + 0) to SUB, and the DUP binders (dup + 0 and dup + 1) to SUB too. then, we register var, or dp0/dp1, to point to the respective binder locations (with a VAR/DP0/DP1 term). on variables, we just return a '0' as a placeholder. then, after all is done, we set all vars, similar to the 'makeVarLine' logic on the compiler. #254: import Control.Monad (foldM) import Control.Monad.State import Data.Word import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid) loc = do lift $ set loc (termNew _REF_ 0 fid) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do (_, state) <- runStateT (injectCore book core 0) emptyState -- Set all variables after the structure is built mapM_ (setVar (args state)) (vars state) got 0 where setVar args (name, loc) = case Map.lookup name args of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam ++ "^" ++ show fid coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: module HVML.Parse where #19: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #20: -- Core Parsers -- ------------ #21: data ParserState = ParserState { constructorAliases :: MS.Map String Word64 } #22: type ParserM = Parsec String ParserState #23: parseCore :: ParserM Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do closeWith ")" arg <- parseCore return arg char ')' return $ foldl App fun args '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> parseCtr '~' -> parseMat _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #24: parseCtr :: ParserM Core parseCtr = do consume "#" nam <- parseName cid <- if length nam == 0 then return 0 else do ali <- constructorAliases <$> getState case MS.lookup nam ali of Just id -> return id Nothing -> case reads nam of [(num, "")] -> return (fromIntegral (num :: Integer)) otherwise -> fail $ "Unknown constructor: " ++ nam fds <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return fds return $ Ctr cid fds #25: parseMat :: ParserM Core parseMat = do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" consume "#" name <- parseName ali <- constructorAliases <$> getState cid <- case MS.lookup name ali of Just id -> return id Nothing -> case reads name of [(num, "")] -> return (fromIntegral (num :: Integer)) _ -> if name == "_" then return 0xFFFFFFF else fail $ "Unknown constructor: " ++ name consume ":" cas <- parseCore return (cid, cas) consume "}" let sortedCss = map snd $ sortOn fst css return $ Mat val sortedCss #26: parseOper :: Oper -> ParserM Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #27: parseName :: ParserM String parseName = skip >> many (alphaNum <|> char '_') #28: parseDef :: ParserM (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore return (name, core) #29: parseADT :: ParserM () parseADT = do try $ do skip consume "data" name <- parseName skip consume "{" constructors <- many parseADTCtr consume "}" let aliases = zip (map fst constructors) [0..] modifyState (\s -> s { constructorAliases = MS.union (MS.fromList aliases) (constructorAliases s) }) #30: parseADTCtr :: ParserM (String, [String]) parseADTCtr = do skip consume "#" name <- parseName fields <- option [] $ do try $ consume "{" fds <- many $ do closeWith "}" parseName skip consume "}" return fds skip return (name, fields) #31: parseBook :: ParserM [(String, Core)] parseBook = do skip many parseADT defs <- many parseDef skip eof return defs #32: doParseCore :: String -> IO Core doParseCore code = case runParser parseCore (ParserState MS.empty) "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #33: doParseBook :: String -> IO Book doParseBook code = case runParser parseBook (ParserState MS.empty) "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #34: -- Helper Parsers -- -------------- #35: consume :: String -> ParserM String consume str = spaces >> string str #36: closeWith :: String -> ParserM () closeWith str = try $ do spaces notFollowedBy (string str) #37: skip :: ParserM () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #38: -- Adjusting -- --------- #39: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #40: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Var nam -> Var nam Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) Ctr cid fds -> Ctr cid (map (decorateFnIds fids) fds) Mat x cs -> Mat (decorateFnIds fids x) (map (decorateFnIds fids) cs) Op2 op x y -> Op2 op (decorateFnIds fids x) (decorateFnIds fids y) U32 n -> U32 n Era -> Era #41: -- Errors -- ------ #42: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #43: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #44: -- //./Type.hs// -- //./Runtime.c// #45: module HVML.Reduce where #46: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #47: import Debug.Trace #48: -- debug a b = trace a b debug a b = b #49: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #50: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #51: normal :: Book -> Term -> HVM Term normal = normalizer reduce #52: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #53: -- //./Type.hs// -- //./Inject.hs// #54: module HVML.Compile where #55: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #56: -- Compilation -- ----------- #57: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #58: type Compile = State CompileState #59: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #60: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #61: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #62: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #63: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #64: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ " Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileCore book fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ " set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileCore book (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ " Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileCore book val (matName ++ " + 0") emit $ " set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,cs) -> compileCore book cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ " set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileCore book (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileCore book (Op2 opr nm0 nm1) host = do uid <- fresh let opxName = "opx" ++ show uid emit $ " Loc " ++ opxName ++ " = alloc_node(2);" nm0T <- compileCore book nm0 (opxName ++ " + 0") nm1T <- compileCore book nm1 (opxName ++ " + 1") emit $ " set(" ++ opxName ++ " + 0, " ++ nm0T ++ ");" emit $ " set(" ++ opxName ++ " + 1, " ++ nm1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxName ++ ")" compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #65: -- Type.hs: -- //./Type.hs// #66: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #67: module Main where #68: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #69: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #70: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #71: -- Main -- ---- #72: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #73: -- CLI Commands -- ------------ #74: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #75: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #76: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #77: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #78: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #79: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #80: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #81: -- Normalize main init <- getCPUTime #82: root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #83: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #84: -- Finalize hvmFree return $ Right () #85: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #86: -- //./Runtime.c// #87: module HVML.Type where #88: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #89: -- Core Types -- ---------- #90: -- NOTE TO AI: we're now adding the uint32 type, including: -- - U32: uint32 value, like '42' -- - OPX: uint32 binary operation, like 'add', 'mul', etc. -- Your goal is to add the uint32 funcionality to each file. #91: data Core = Var String | Ref String Word64 | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ctr Word64 [Core] | Mat Core [Core] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #92: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #93: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #94: -- Runtime Types -- ------------- #95: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #96: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #97: type HVM = IO #98: -- C Functions -- ----------- #99: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #100: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #101: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #102: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #103: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #104: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #105: foreign import ccall unsafe "Runtime.c swap" swap :: Word64 -> IO Term #106: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #107: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #108: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #109: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #110: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #111: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #112: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #113: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #114: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #115: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #116: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #117: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #118: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #119: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #120: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #121: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #122: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #123: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #124: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #125: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #126: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #127: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #128: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #129: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #130: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #131: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #132: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #133: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #134: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #135: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #136: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #137: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #138: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #139: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #140: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #141: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #142: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #143: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #144: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #145: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #146: -- Constants -- --------- #147: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag: " ++ show tag #148: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #149: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #150: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #151: typedef _Atomic(Term) ATerm; #152: // Runtime Types // ------------- #153: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #154: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #155: // Constants // --------- #156: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #157: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #158: #define VOID 0x00000000000000 #159: // Heap // ---- #160: Loc get_len() { return *HVM.size; } #161: Loc get_itr() { return *HVM.itrs; } #162: void set_len(Loc value) { *HVM.size = value; } #163: void set_itr(Loc value) { *HVM.itrs = value; } #164: // Terms // ------ #165: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #166: Tag term_tag(Term x) { return x & 0xFF; } #167: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #168: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #169: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #170: // u12v2 // ----- #171: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #172: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #173: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #174: // Atomics // ------- #175: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #176: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #177: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #178: Term take(Loc loc) { return swap(loc, VOID); } #179: // Allocation // ---------- #180: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #181: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #182: // Stringification // --------------- #183: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #184: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #185: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #186: // Evaluation // ---------- #187: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #188: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #189: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #190: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #191: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #192: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #193: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #194: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #195: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #196: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #197: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #198: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #199: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #200: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #201: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #202: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #203: // TODO: now, let's implement the missing OPX interactions. #204: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #205: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #206: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #207: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #208: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); set(opx_loc + 0, w32); return term_new(OPY, opx_lab, opx_loc); } #209: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #210: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #211: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #212: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #213: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #214: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPX: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPY: { HVM.path[spos++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #215: // Runtime Memory // -------------- #216: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #217: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #218: State* hvm_get_state() { return &HVM; } #219: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #220: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #221: // Main // ---- #222: //#include "book.c" #223: //int main() { //hvm_init(); //inject_P24(); #224: //clock_t start = clock(); #225: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #226: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #227: //hvm_free(); //return 0; //} ./Extract.hs #228: -- //./Type.hs// #229: module HVML.Extract where #230: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #231: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #232: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let ari = termLab term val <- lift $ got (loc + 0) css <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..ari-1] val0 <- extractCore val css0 <- mapM extractCore css return $ Mat val0 css0 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term return $ Ref "?" loc _ -> return Era #233: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #234: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #235: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #236: -- //./Type.hs// #237: module HVML.Inject where #238: import Control.Monad (foldM) import Control.Monad.State import Data.Word import HVML.Type import qualified Data.Map.Strict as Map #239: type InjectM a = StateT InjectState HVM a #240: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #241: emptyState :: InjectState emptyState = InjectState Map.empty [] #242: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #243: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #244: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #245: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #246: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #247: injectCore book (Ref nam fid) loc = do lift $ set loc (termNew _REF_ 0 fid) #248: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #249: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #250: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #251: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #252: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #253: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do (_, state) <- runStateT (injectCore book core 0) emptyState -- Set all variables after the structure is built mapM_ (setVar (args state)) (vars state) got 0 where setVar args (name, loc) = case Map.lookup name args of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name

d43999c248149af4191af5723b7aee8f0083c3f6

synchronize treatment of variables on inject and compile

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// -- //./Show.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do notFollowedBy (char ')') arg <- parseCore return arg char ')' return $ foldl App fun args '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #23: parseOper :: Oper -> Parser Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #24: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #25: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore -- trace ("parsed " ++ coreToString core) $ return (name, core) #26: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #27: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #28: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #29: -- Helper Parsers -- -------------- #30: consume :: String -> Parser String consume str = spaces >> string str #31: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #32: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #33: -- Adjusting -- --------- #34: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #35: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #36: -- Errors -- ------ #37: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #38: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #39: -- //./Type.hs// -- //./Runtime.c// #40: module HVML.Reduce where #41: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #42: import Debug.Trace #43: -- debug a b = trace a b debug a b = b #44: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #45: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #46: normal :: Book -> Term -> HVM Term normal = normalizer reduce #47: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #48: -- //./Type.hs// -- //./Inject.hs// #49: module HVML.Compile where #50: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #51: -- Compilation -- ----------- #52: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #53: type Compile = State CompileState #54: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #55: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #56: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #57: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #58: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #59: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ " Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileCore book fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ " set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileCore book (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ " Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileCore book val (matName ++ " + 0") emit $ " set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,cs) -> compileCore book cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ " set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileCore book (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileCore book (Op2 opr nm0 nm1) host = do uid <- fresh let opxName = "opx" ++ show uid emit $ " Loc " ++ opxName ++ " = alloc_node(2);" nm0T <- compileCore book nm0 (opxName ++ " + 0") nm1T <- compileCore book nm1 (opxName ++ " + 1") emit $ " set(" ++ opxName ++ " + 0, " ++ nm0T ++ ");" emit $ " set(" ++ opxName ++ " + 1, " ++ nm1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxName ++ ")" compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #60: -- Type.hs: -- //./Type.hs// #61: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #62: module Main where #63: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #64: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #65: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #66: -- Main -- ---- #67: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #68: -- CLI Commands -- ------------ #69: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #70: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #71: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #72: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #73: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #74: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #75: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #76: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root norm <- doExtractCore done putStrLn $ coreToString norm #77: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #78: -- Finalize hvmFree return $ Right () #79: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #80: -- //./Runtime.c// #81: module HVML.Type where #82: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #83: -- Core Types -- ---------- #84: -- NOTE TO AI: we're now adding the uint32 type, including: -- - U32: uint32 value, like '42' -- - OPX: uint32 binary operation, like 'add', 'mul', etc. -- Your goal is to add the uint32 funcionality to each file. #85: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #86: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #87: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #88: -- Runtime Types -- ------------- #89: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #90: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #91: type HVM = IO #92: -- C Functions -- ----------- #93: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #94: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #95: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #96: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #97: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #98: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #99: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #100: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #101: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #102: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #103: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #104: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #105: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #106: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #107: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #108: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #109: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #110: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #111: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #112: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #113: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #114: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #115: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #116: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #117: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #118: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #119: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #120: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #121: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #122: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #123: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #124: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #125: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #126: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #127: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #128: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #129: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #130: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #131: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #132: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #133: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #134: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #135: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #136: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #137: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #138: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #139: -- Constants -- --------- #140: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag" ++ show tag #141: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #142: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #143: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #144: typedef _Atomic(Term) ATerm; #145: // Runtime Types // ------------- #146: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #147: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #148: // Constants // --------- #149: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #150: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #151: #define VOID 0x00000000000000 #152: // Heap // ---- #153: Loc get_len() { return *HVM.size; } #154: Loc get_itr() { return *HVM.itrs; } #155: void set_len(Loc value) { *HVM.size = value; } #156: void set_itr(Loc value) { *HVM.itrs = value; } #157: // Terms // ------ #158: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #159: Tag term_tag(Term x) { return x & 0xFF; } #160: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #161: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #162: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #163: // u12v2 // ----- #164: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #165: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #166: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #167: // Atomics // ------- #168: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #169: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #170: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #171: Term take(Loc loc) { return swap(loc, VOID); } #172: // Allocation // ---------- #173: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #174: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #175: // Stringification // --------------- #176: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #177: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #178: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #179: // Evaluation // ---------- #180: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #181: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #182: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #183: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #184: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #185: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #186: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #187: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #188: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #189: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #190: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #191: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #192: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #193: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #194: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #195: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #196: // TODO: now, let's implement the missing OPX interactions. #197: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #198: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #199: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #200: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #201: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); return term_new(OPY, opx_lab, opx_loc); } #202: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #203: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #204: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #205: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #206: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #207: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPX: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPY: { HVM.path[spos++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #208: // Runtime Memory // -------------- #209: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #210: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #211: State* hvm_get_state() { return &HVM; } #212: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #213: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #214: // Main // ---- #215: //#include "book.c" #216: //int main() { //hvm_init(); //inject_P24(); #217: //clock_t start = clock(); #218: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #219: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #220: //hvm_free(); //return 0; //} ./Extract.hs #221: -- //./Type.hs// #222: module HVML.Extract where #223: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #224: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #225: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let ari = termLab term val <- lift $ got (loc + 0) css <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..ari-1] val0 <- extractCore val css0 <- mapM extractCore css return $ Mat val0 css0 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term return $ Ref "?" loc _ -> return Era #226: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #227: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #228: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #229: -- //./Type.hs// #230: module HVML.Inject where #231: import Control.Monad (foldM) import Control.Monad.State import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM #232: type InjectM a = StateT (IM.IntMap (Maybe Term)) HVM a #233: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #234: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 injectBind vr0 (termNew _VAR_ 0 (lam + 0)) injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #235: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #236: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #237: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 injectBind dp0 (termNew _DP0_ lab dup) injectBind dp1 (termNew _DP1_ lab dup) injectCore book val (dup + 2) injectCore book bod loc #238: injectCore book (Ref nam fid) loc = do lift $ set loc (termNew _REF_ 0 fid) #239: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #240: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #241: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #242: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #243: injectCore _ (Var uid) loc = do let namHash = hash uid vars <- get case IM.lookup namHash vars of Nothing -> put $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> put $ IM.insert namHash (Just loc) vars Just oldVar -> do lift $ set loc oldVar put $ IM.insert namHash (Just loc) vars where hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #244: injectBind :: String -> Term -> InjectM () injectBind nam var = do let subKey = termKey var let namHash = hash nam vars <- get case IM.lookup namHash vars of Nothing -> do lift $ set subKey (termNew _SUB_ 0 0) put $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do lift $ set subKey (termNew _SUB_ 0 0) put $ IM.insert namHash (Just var) vars Just oldVar -> do lift $ set oldVar var lift $ set subKey (termNew _SUB_ 0 0) put $ IM.insert namHash (Just var) vars where hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #245: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do evalStateT (injectCore book core 0) IM.empty got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// -- //./Show.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore args <- many $ do notFollowedBy (char ')') arg <- parseCore return arg char ')' return $ foldl App fun args '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #23: parseOper :: Oper -> Parser Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #24: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #25: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore -- trace ("parsed " ++ coreToString core) $ return (name, core) #26: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #27: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #28: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #29: -- Helper Parsers -- -------------- #30: consume :: String -> Parser String consume str = spaces >> string str #31: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #32: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #33: -- Adjusting -- --------- #34: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #35: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #36: -- Errors -- ------ #37: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #38: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #39: -- //./Type.hs// -- //./Runtime.c// #40: module HVML.Reduce where #41: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #42: import Debug.Trace #43: -- debug a b = trace a b debug a b = b #44: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #45: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do let cid = u12v2X lab let ari = u12v2Y lab args <- mapM (\i -> got (loc + i)) (if ari == 0 then [] else [0 .. ari - 1]) args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do let ari = lab args <- mapM (\i -> got (loc + i)) [0 .. ari] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #46: normal :: Book -> Term -> HVM Term normal = normalizer reduce #47: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #48: -- //./Type.hs// -- //./Inject.hs// #49: module HVML.Compile where #50: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #51: -- Compilation -- ----------- #52: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #53: type Compile = State CompileState #54: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #55: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #56: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #57: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #58: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #59: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ " Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileCore book fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ " set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileCore book (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ " Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileCore book val (matName ++ " + 0") emit $ " set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,cs) -> compileCore book cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ " set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileCore book (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileCore book (Op2 opr nm0 nm1) host = do uid <- fresh let opxName = "opx" ++ show uid emit $ " Loc " ++ opxName ++ " = alloc_node(2);" nm0T <- compileCore book nm0 (opxName ++ " + 0") nm1T <- compileCore book nm1 (opxName ++ " + 1") emit $ " set(" ++ opxName ++ " + 0, " ++ nm0T ++ ");" emit $ " set(" ++ opxName ++ " + 1, " ++ nm1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxName ++ ")" compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #60: -- Type.hs: -- //./Type.hs// #61: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #62: module Main where #63: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #64: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #65: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #66: -- Main -- ---- #67: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #68: -- CLI Commands -- ------------ #69: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #70: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #71: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #72: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #73: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #74: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #75: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #76: -- Normalize main init <- getCPUTime #77: root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root -- done <- reduce book root norm <- doExtractCore done putStrLn $ coreToString norm #78: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #79: -- Finalize hvmFree return $ Right () #80: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #81: -- //./Runtime.c// #82: module HVML.Type where #83: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #84: -- Core Types -- ---------- #85: -- NOTE TO AI: we're now adding the uint32 type, including: -- - U32: uint32 value, like '42' -- - OPX: uint32 binary operation, like 'add', 'mul', etc. -- Your goal is to add the uint32 funcionality to each file. #86: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #87: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #88: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #89: -- Runtime Types -- ------------- #90: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #91: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #92: type HVM = IO #93: -- C Functions -- ----------- #94: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #95: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #96: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #97: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #98: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #99: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #100: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #101: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #102: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #103: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #104: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #105: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #106: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #107: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #108: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #109: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #110: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #111: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #112: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #113: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #114: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #115: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #116: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #117: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #118: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #119: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #120: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #121: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #122: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #123: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #124: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #125: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #126: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #127: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #128: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #129: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #130: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #131: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #132: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #133: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #134: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #135: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #136: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #137: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #138: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #139: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #140: -- Constants -- --------- #141: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag: " ++ show tag #142: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #143: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #144: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #145: typedef _Atomic(Term) ATerm; #146: // Runtime Types // ------------- #147: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #148: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #149: // Constants // --------- #150: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #151: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #152: #define VOID 0x00000000000000 #153: // Heap // ---- #154: Loc get_len() { return *HVM.size; } #155: Loc get_itr() { return *HVM.itrs; } #156: void set_len(Loc value) { *HVM.size = value; } #157: void set_itr(Loc value) { *HVM.itrs = value; } #158: // Terms // ------ #159: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #160: Tag term_tag(Term x) { return x & 0xFF; } #161: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #162: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #163: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #164: // u12v2 // ----- #165: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #166: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #167: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #168: // Atomics // ------- #169: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #170: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #171: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #172: Term take(Loc loc) { return swap(loc, VOID); } #173: // Allocation // ---------- #174: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #175: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #176: // Stringification // --------------- #177: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #178: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #179: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #180: // Evaluation // ---------- #181: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #182: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #183: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #184: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #185: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #186: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #187: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #188: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #189: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #190: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #191: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #192: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #193: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #194: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #195: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #196: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #197: // TODO: now, let's implement the missing OPX interactions. #198: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #199: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #200: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #201: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #202: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); return term_new(OPY, opx_lab, opx_loc); } #203: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #204: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #205: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #206: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #207: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #208: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPX: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPY: { HVM.path[spos++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #209: // Runtime Memory // -------------- #210: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #211: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #212: State* hvm_get_state() { return &HVM; } #213: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #214: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #215: // Main // ---- #216: //#include "book.c" #217: //int main() { //hvm_init(); //inject_P24(); #218: //clock_t start = clock(); #219: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #220: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #221: //hvm_free(); //return 0; //} ./Extract.hs #222: -- //./Type.hs// #223: module HVML.Extract where #224: import Control.Monad (foldM) import Control.Monad.State import Data.Char (chr, ord) import HVML.Type import qualified Data.IntSet as IS import qualified Data.Map.Strict as MS #225: type ExtractM a = StateT (IS.IntSet, MS.Map Loc String) HVM a #226: extractCore :: Term -> ExtractM Core extractCore term = case tagT (termTag term) of ERA -> do return Era LAM -> do let loc = termLoc term bod <- lift $ got (loc + 1) name <- genName (loc + 0) bod0 <- extractCore bod return $ Lam name bod0 APP -> do let loc = termLoc term fun <- lift $ got (loc + 0) arg <- lift $ got (loc + 1) fun0 <- extractCore fun arg0 <- extractCore arg return $ App fun0 arg0 SUP -> do let loc = termLoc term let lab = termLab term tm0 <- lift $ got (loc + 0) tm1 <- lift $ got (loc + 1) tm00 <- extractCore tm0 tm10 <- extractCore tm1 return $ Sup lab tm00 tm10 VAR -> do let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do name <- genName key return $ Var name else extractCore sub DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp0) else extractCore sub DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- lift $ got key if termTag sub == _SUB_ then do (dups, nameMap) <- get if IS.member (fromIntegral loc) dups then do name <- genName key return $ Var name else do dp0 <- genName (loc + 0) dp1 <- genName (loc + 1) val <- lift $ got (loc + 2) put (IS.insert (fromIntegral loc) dups, nameMap) val0 <- extractCore val return $ Dup lab dp0 dp1 val0 (Var dp1) else extractCore sub CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + i)) [0..ari-1] fds0 <- mapM extractCore fds return $ Ctr cid fds0 MAT -> do let loc = termLoc term let ari = termLab term val <- lift $ got (loc + 0) css <- if ari == 0 then return [] else lift $ mapM (\i -> got (loc + 1 + i)) [0..ari-1] val0 <- extractCore val css0 <- mapM extractCore css return $ Mat val0 css0 W32 -> do let val = termLoc term return $ U32 (fromIntegral val) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- lift $ got (loc + 0) nm1 <- lift $ got (loc + 1) nm00 <- extractCore nm0 nm10 <- extractCore nm1 return $ Op2 opr nm00 nm10 REF -> do let loc = termLoc term return $ Ref "?" loc _ -> return Era #227: doExtractCore :: Term -> HVM Core doExtractCore term = evalStateT (extractCore term) (IS.empty, MS.empty) #228: genName :: Loc -> ExtractM String genName loc = do (dups, nameMap) <- get case MS.lookup loc nameMap of Just name -> do return name Nothing -> do let newName = genNameFromIndex (MS.size nameMap) put (dups, MS.insert loc newName nameMap) return newName #229: genNameFromIndex :: Int -> String genNameFromIndex n = go (n + 1) "" where go n ac | n == 0 = ac | otherwise = go q (chr (ord 'a' + r) : ac) where (q,r) = quotRem (n - 1) 26 ./Inject.hs #230: -- //./Type.hs// #231: module HVML.Inject where #232: -- import Control.Monad (foldM) -- import Control.Monad.State -- import Data.Word -- import HVML.Type -- import qualified Data.IntMap.Strict as IM #233: -- type InjectM a = StateT (IM.IntMap (Maybe Term)) HVM a #234: -- injectCore :: Book -> Core -> Loc -> InjectM () -- injectCore _ Era loc = do -- lift $ set loc (termNew _ERA_ 0 0) #235: -- injectCore book (Lam vr0 bod) loc = do -- lam <- lift $ allocNode 2 -- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) -- injectCore book bod (lam + 1) -- lift $ set loc (termNew _LAM_ 0 lam) #236: -- injectCore book (App fun arg) loc = do -- app <- lift $ allocNode 2 -- injectCore book fun (app + 0) -- injectCore book arg (app + 1) -- lift $ set loc (termNew _APP_ 0 app) #237: -- injectCore book (Sup lab tm0 tm1) loc = do -- sup <- lift $ allocNode 2 -- injectCore book tm0 (sup + 0) -- injectCore book tm1 (sup + 1) -- lift $ set loc (termNew _SUP_ lab sup) #238: -- injectCore book (Dup lab dp0 dp1 val bod) loc = do -- dup <- lift $ allocNode 3 -- injectBind dp0 (termNew _DP0_ lab dup) -- injectBind dp1 (termNew _DP1_ lab dup) -- injectCore book val (dup + 2) -- injectCore book bod loc #239: -- injectCore book (Ref nam fid) loc = do -- lift $ set loc (termNew _REF_ 0 fid) #240: -- injectCore book (Ctr cid fds) loc = do -- let arity = length fds -- ctr <- lift $ allocNode (fromIntegral arity) -- sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] -- lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #241: -- injectCore book (Mat val css) loc = do -- mat <- lift $ allocNode (1 + fromIntegral (length css)) -- injectCore book val (mat + 0) -- sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] -- lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #242: -- injectCore book (U32 val) loc = do -- lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #243: -- injectCore book (Op2 opr nm0 nm1) loc = do -- opx <- lift $ allocNode 2 -- injectCore book nm0 (opx + 0) -- injectCore book nm1 (opx + 1) -- lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #244: -- injectCore _ (Var uid) loc = do -- let namHash = hash uid -- vars <- get -- case IM.lookup namHash vars of -- Nothing -> put $ IM.insert namHash (Just loc) vars -- Just mOldVar -> case mOldVar of -- Nothing -> put $ IM.insert namHash (Just loc) vars -- Just oldVar -> do -- lift $ set loc oldVar -- put $ IM.insert namHash (Just loc) vars -- where -- hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #245: -- injectBind :: String -> Term -> InjectM () -- injectBind nam var = do -- let subKey = termKey var -- let namHash = hash nam -- vars <- get -- case IM.lookup namHash vars of -- Nothing -> do -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- Just mOldVar -> case mOldVar of -- Nothing -> do -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- Just oldVar -> do -- lift $ set oldVar var -- lift $ set subKey (termNew _SUB_ 0 0) -- put $ IM.insert namHash (Just var) vars -- where -- hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #246: -- doInjectCore :: Book -> Core -> HVM Term -- doInjectCore book core = do -- evalStateT (injectCore book core 0) IM.empty -- got 0 #247: -- TODO: refactor this to use a similar algorithm to Compile.hs -- for handling variables. that is, we should keep a map of args, -- and a list of vars found. and we should only set the variables -- AFTER injectCore has fully returned. -- remember: we should keep two states: -- args : var_name => binder_host -- vars : [(var_name, var_host)] -- do you understand the assignment? answer below in english #248: -- Yes, I understand the assignment. The goal is to refactor the variable handling in injectCore to: #249: -- 1. Use two separate state components: -- - args: A map from variable names to their binder locations (where variables are bound) -- - vars: A list of tuples containing variable names and their usage locations #250: -- 2. Change the algorithm to: -- - First traverse the term collecting all variable usages without setting them -- - Only after the full traversal is complete, go through the vars list and set the appropriate references #251: -- This approach would be more similar to Compile.hs and would handle variable scoping more cleanly by separating the collection of variable information from the actual setting of references in memory. #252: -- The key difference from the current implementation is that variable references would not be set immediately during traversal, but rather collected and processed in a second pass after the full term structure is built. #253: -- yes. remember: we always set the LAM binder (lam + 0) to SUB, and the DUP binders (dup + 0 and dup + 1) to SUB too. then, we register var, or dp0/dp1, to point to the respective binder locations (with a VAR/DP0/DP1 term). on variables, we just return a '0' as a placeholder. then, after all is done, we set all vars, similar to the 'makeVarLine' logic on the compiler. #254: import Control.Monad (foldM) import Control.Monad.State import Data.Word import HVML.Type import qualified Data.Map.Strict as Map #255: type InjectM a = StateT InjectState HVM a #256: data InjectState = InjectState { args :: Map.Map String Term -- maps var names to binder locations , vars :: [(String, Loc)] -- list of (var name, usage location) pairs } #257: emptyState :: InjectState emptyState = InjectState Map.empty [] #258: injectCore :: Book -> Core -> Loc -> InjectM () injectCore _ Era loc = do lift $ set loc (termNew _ERA_ 0 0) #259: injectCore book (Lam vr0 bod) loc = do lam <- lift $ allocNode 2 lift $ set (lam + 0) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert vr0 (termNew _VAR_ 0 (lam + 0)) (args s) } injectCore book bod (lam + 1) lift $ set loc (termNew _LAM_ 0 lam) #260: injectCore book (App fun arg) loc = do app <- lift $ allocNode 2 injectCore book fun (app + 0) injectCore book arg (app + 1) lift $ set loc (termNew _APP_ 0 app) #261: injectCore book (Sup lab tm0 tm1) loc = do sup <- lift $ allocNode 2 injectCore book tm0 (sup + 0) injectCore book tm1 (sup + 1) lift $ set loc (termNew _SUP_ lab sup) #262: injectCore book (Dup lab dp0 dp1 val bod) loc = do dup <- lift $ allocNode 3 lift $ set (dup + 0) (termNew _SUB_ 0 0) lift $ set (dup + 1) (termNew _SUB_ 0 0) modify $ \s -> s { args = Map.insert dp0 (termNew _DP0_ lab dup) $ Map.insert dp1 (termNew _DP1_ lab dup) (args s) } injectCore book val (dup + 2) injectCore book bod loc #263: injectCore book (Ref nam fid) loc = do lift $ set loc (termNew _REF_ 0 fid) #264: injectCore book (Ctr cid fds) loc = do let arity = length fds ctr <- lift $ allocNode (fromIntegral arity) sequence_ [injectCore book fd (ctr + ix) | (ix,fd) <- zip [0..] fds] lift $ set loc (termNew _CTR_ (u12v2New cid (fromIntegral arity)) ctr) #265: injectCore book (Mat val css) loc = do mat <- lift $ allocNode (1 + fromIntegral (length css)) injectCore book val (mat + 0) sequence_ [injectCore book bod (mat + 1 + ix) | (ix,bod) <- zip [0..] css] lift $ set loc (termNew _MAT_ (fromIntegral (length css)) mat) #266: injectCore book (U32 val) loc = do lift $ set loc (termNew _W32_ 0 (fromIntegral val)) #267: injectCore book (Op2 opr nm0 nm1) loc = do opx <- lift $ allocNode 2 injectCore book nm0 (opx + 0) injectCore book nm1 (opx + 1) lift $ set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) #268: injectCore _ (Var nam) loc = do modify $ \s -> s { vars = (nam, loc) : vars s } lift $ set loc 0 -- placeholder #269: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do (_, state) <- runStateT (injectCore book core 0) emptyState -- Set all variables after the structure is built mapM_ (setVar (args state)) (vars state) got 0 where setVar args (name, loc) = case Map.lookup name args of Just term -> set loc term Nothing -> error $ "Unbound variable: " ++ name

a8e705ce95cea3f94da5e5053384dfbc70d2f813

U32 numbers WIP this was mostly AI generated and is pending review

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = "x" ++ nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λx" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" #6: -- Runtime Stringification -- ----------------------- #7: tagToString :: Tag -> String tagToString t = show (tagT t) #8: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #9: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #10: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #11: -- Dumping -- ------- #12: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #13: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #14: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #15: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #16: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #17: -- //./Type.hs// #18: module HVML.Parse where #19: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #20: -- Core Parsers -- ------------ #21: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName return $ Var name #22: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #23: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore return (name, core) #24: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #25: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #26: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #27: -- Helper Parsers -- -------------- #28: consume :: String -> Parser String consume str = spaces >> string str #29: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #30: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #31: -- Adjusting -- --------- #32: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #33: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #34: -- Errors -- ------ #35: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #36: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Compile.hs #37: -- //./Type.hs// #38: module HVML.Compile where #39: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #40: -- Compilation -- ----------- #41: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #42: type Compile = State CompileState #43: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #44: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #45: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #46: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #47: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #48: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #49: -- Type.hs: -- //./Type.hs// #50: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #51: module Main where #52: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #53: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #54: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #55: -- Main -- ---- #56: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #57: -- CLI Commands -- ------------ #58: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #59: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #60: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #61: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #62: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #63: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #64: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #65: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root norm <- doExtractCore done putStrLn $ coreToString norm #66: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #67: -- Finalize hvmFree return $ Right () #68: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #69: -- //./Runtime.c// #70: module HVML.Type where #71: import Data.Word import Data.Map.Strict as MS import Foreign.Ptr #72: -- Core Types -- ---------- #73: -- REFACTOR NOTE: we just added a Word64 field to Sup/Dup. it is called 'lab'. #74: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] deriving (Show, Eq) #75: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #76: -- Runtime Types -- ------------- #77: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #78: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT deriving (Eq, Show) #79: type HVM = IO #80: -- C Functions -- ----------- #81: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #82: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #83: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #84: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #85: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #86: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #87: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #88: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #89: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #90: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #91: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #92: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #93: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #94: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #95: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #96: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #97: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #98: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #99: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #100: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #101: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #102: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #103: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #104: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #105: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #106: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #107: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #108: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #109: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #110: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #111: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #112: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #113: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #114: -- Constants -- --------- #115: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT tag = error $ "unknown tag" ++ show tag #116: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A ./Runtime.c #117: //./Type.hs// //./Inject.hs// #118: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #119: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint64_t u64; #120: typedef _Atomic(Term) ATerm; #121: // Runtime Types // ------------- #122: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #123: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #124: // Constants // --------- #125: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #126: #define VOID 0x00000000000000 #127: // Heap // ---- #128: Loc get_len() { return *HVM.size; } #129: Loc get_itr() { return *HVM.itrs; } #130: void set_len(Loc value) { *HVM.size = value; } #131: void set_itr(Loc value) { *HVM.itrs = value; } #132: // Terms // ------ #133: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #134: Tag term_tag(Term x) { return x & 0xFF; } #135: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #136: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #137: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #138: // u12v2 // ----- #139: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #140: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #141: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #142: // Atomics // ------- #143: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #144: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #145: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #146: Term take(Loc loc) { return swap(loc, VOID); } #147: // Allocation // ---------- #148: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #149: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #150: // Stringification // --------------- #151: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #152: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #153: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #154: // Evaluation // ---------- #155: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #156: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #157: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #158: // (&L{a b} c) // ----------------- APP-SUP // &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #159: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #160: // &L{x y} = * // ----------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #161: // &L{r s} = λx(f) // --------------- DUP-LAM // &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #162: // &L{x y} = &R{a b} // ----------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // &L{a0 a1} = a // &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #163: // &{x y} = #{a b c ...} // --------------------- DUP-CTR // &{a0 a1} = a // &{b0 b1} = b // &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #164: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #165: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #166: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // &{k0a k0b} = K0 // &{k1a k1b} = K1 // &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #167: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #168: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); exit(0); case LAM: next = reduce_mat_lam(prev, next); exit(0); case SUP: next = reduce_mat_sup(prev, next); exit(0); case CTR: next = reduce_mat_ctr(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #169: //Term normal(Term term) { //Term wnf = reduce(term); //Tag tag = term_tag(wnf); //Lab lab = term_lab(wnf); //Loc loc = term_loc(wnf); //switch (tag) { //case APP: { //Term fun; //Term arg; //fun = got(loc + 0); //fun = normal(fun); //arg = got(loc + 1); //arg = normal(arg); //set(loc + 0, fun); //set(loc + 1, arg); //return wnf; //} //case LAM: { //Term bod; //bod = got(loc + 1); //bod = normal(bod); //set(loc + 1, bod); //return wnf; //} //case SUP: { //Term tm0; //Term tm1; //tm0 = got(loc + 0); //tm0 = normal(tm0); //tm1 = got(loc + 1); //tm1 = normal(tm1); //set(loc + 0, tm0); //set(loc + 1, tm1); //return wnf; //} //case DP0: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //case DP1: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //default: //return wnf; //} //} #170: // Runtime Memory // -------------- #171: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #172: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #173: // TODO: create an hvm_get and an hvm_set function that get/set the whole HVM struct State* hvm_get_state() { return &HVM; } #174: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #175: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #176: // Main // ---- #177: //#include "book.c" #178: //int main() { //hvm_init(); //inject_P24(); #179: //clock_t start = clock(); #180: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #181: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #182: //hvm_free(); //return 0; //} ./Extract.hs #183: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// #184: module HVML.Extract where #185: import Control.Monad (foldM) import HVML.Type import qualified Data.IntSet as IS #186: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> do return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term let lab = termLab term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup lab tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp1)) else extractCore sub dups CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0..ari-1] (dups0, fds) <- foldM (\ (dups,fds) fd -> do (dups0, fd0) <- extractCore fd dups return (dups0, fds ++ [fd0])) (dups,[]) fds return (dups0, Ctr cid fds) MAT -> do let loc = termLoc term let ari = termLab term val <- got (loc + 0) css <- if ari == 0 then return [] else mapM (\i -> got (loc + 1 + i)) [0..ari-1] (dups0, val0) <- extractCore val dups (dups1, css0) <- foldM (\ (dups,css) cs -> do (dups0, cs0) <- extractCore cs dups return (dups0, css ++ [cs0])) (dups0,[]) css return (dups1, Mat val0 css0) REF -> do let loc = termLoc term return (dups, Ref "?" loc) _ -> do return (dups, Era) #187: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #188: -- //./Type.hs// #189: module HVML.Inject where #190: import Control.Monad (foldM) import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #191: type VarMap = IM.IntMap (Maybe Term) #192: injectCore :: Book -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore book (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore book bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore book (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore book fun (app + 0) vars vars1 <- injectCore book arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore book (Sup lab tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore book tm0 (sup + 0) vars vars1 <- injectCore book tm1 (sup + 1) vars0 set loc (termNew _SUP_ lab sup) return vars1 injectCore book (Dup lab dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ lab dup) vars vars1 <- injectBind dp1 (termNew _DP1_ lab dup) vars0 vars2 <- injectCore book val (dup + 2) vars1 injectCore book bod loc vars2 injectCore book (Ref nam fid) loc vars = do set loc (termNew _REF_ 0 fid) return vars injectCore book (Ctr cid fds) loc vars = do let arity = length fds ctr <- allocNode (fromIntegral arity) vars0 <- foldM (\vs (ix,fd) -> injectCore book fd (ctr + ix) vs) vars (zip [0..] fds) set loc (termNew _CTR_ (u12v2New cid (fromIntegral (length fds))) ctr) return vars0 injectCore book (Mat val css) loc vars = do mat <- allocNode (1 + fromIntegral (length css)) vars0 <- injectCore book val (mat + 0) vars vars1 <- foldM (\vs (ix,bod) -> do injectCore book bod (mat + 1 + ix) vs) vars0 (zip [0..] css) set loc (termNew _MAT_ (fromIntegral (length css)) mat) return vars1 injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #193: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #194: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do injectCore book core 0 IM.empty got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = "x" ++ nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λx" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" coreToString (U32 val) = show val coreToString (Op2 opr nm0 nm1) = "(" ++ operToString opr ++ coreToString nm0 ++ " " ++ coreToString nm1 ++ ")" #6: operToString :: Oper -> String operToString OP_ADD = "+" operToString OP_SUB = "-" operToString OP_MUL = "*" operToString OP_DIV = "/" operToString OP_MOD = "%" operToString OP_EQ = "==" operToString OP_NE = "!=" operToString OP_LT = "<" operToString OP_GT = ">" operToString OP_LTE = "<=" operToString OP_GTE = ">=" operToString OP_AND = "&" operToString OP_OR = "|" operToString OP_XOR = "^" operToString OP_LSH = "<<" operToString OP_RSH = ">>" #7: -- Runtime Stringification -- ----------------------- #8: tagToString :: Tag -> String tagToString t = show (tagT t) #9: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #10: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #11: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #12: -- Dumping -- ------- #13: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #14: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #15: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #16: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #17: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #18: -- //./Type.hs// -- //./Show.hs// #19: module HVML.Parse where #20: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #21: -- Core Parsers -- ------------ #22: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do next <- lookAhead (anyChar >> anyChar) case next of '+' -> parseOper OP_ADD '-' -> parseOper OP_SUB '*' -> parseOper OP_MUL '/' -> parseOper OP_DIV '%' -> parseOper OP_MOD '=' -> parseOper OP_EQ '!' -> parseOper OP_NE '&' -> parseOper OP_AND '|' -> parseOper OP_OR '^' -> parseOper OP_XOR '<' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '<' -> parseOper OP_LSH '=' -> parseOper OP_LTE _ -> parseOper OP_LT '>' -> do next <- lookAhead (anyChar >> anyChar >> anyChar) case next of '>' -> parseOper OP_RSH '=' -> parseOper OP_GTE _ -> parseOper OP_GT _ -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName case reads name of [(num, "")] -> return $ U32 (fromIntegral (num :: Integer)) _ -> return $ Var name #23: parseOper :: Oper -> Parser Core parseOper op = do consume "(" consume (operToString op) nm0 <- parseCore nm1 <- parseCore consume ")" return $ Op2 op nm0 nm1 #24: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #25: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore return (name, core) #26: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #27: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #28: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #29: -- Helper Parsers -- -------------- #30: consume :: String -> Parser String consume str = spaces >> string str #31: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #32: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #33: -- Adjusting -- --------- #34: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #35: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #36: -- Errors -- ------ #37: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #38: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Reduce.hs #39: -- //./Type.hs// -- //./Runtime.c// #40: module HVML.Reduce where #41: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #42: import Debug.Trace #43: -- debug a b = trace a b debug a b = b #44: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book W32 -> reduceAppW32 term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book W32 -> reduceDupW32 term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book W32 -> reduceMatW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPX -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpxEra term val >>= reduce book LAM -> reduceOpxLam term val >>= reduce book SUP -> reduceOpxSup term val >>= reduce book CTR -> reduceOpxCtr term val >>= reduce book W32 -> reduceOpxW32 term val >>= reduce book _ -> set (loc + 0) val >> return term OPY -> do val <- got (loc + 1) val <- reduce book val case tagT (termTag val) of ERA -> reduceOpyEra term val >>= reduce book LAM -> reduceOpyLam term val >>= reduce book SUP -> reduceOpySup term val >>= reduce book CTR -> reduceOpyCtr term val >>= reduce book W32 -> reduceOpyW32 term val >>= reduce book _ -> set (loc + 1) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #45: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf CTR -> do args <- mapM (\i -> got (loc + i)) [0..termLab wnf - 1] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf MAT -> do args <- mapM (\i -> got (loc + i)) [0..termLab wnf] args <- mapM (normalizer reducer book) args mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args return wnf _ -> do return wnf #46: normal :: Book -> Term -> HVM Term normal = normalizer reduce #47: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Compile.hs #48: -- //./Type.hs// -- //./Inject.hs// #49: module HVML.Compile where #50: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #51: -- Compilation -- ----------- #52: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #53: type Compile = State CompileState #54: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #55: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #56: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #57: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #58: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #59: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ctr cid fds) host = do uid <- fresh let ctrName = "ctr" ++ show uid let arity = length fds emit $ " Loc " ++ ctrName ++ " = alloc_node(" ++ show arity ++ ");" fdsT <- mapM (\ (i,fd) -> compileCore book fd (ctrName ++ " + " ++ show i)) (zip [0..] fds) sequence_ [emit $ " set(" ++ ctrName ++ " + " ++ show i ++ ", " ++ fdT ++ ");" | (i,fdT) <- zip [0..] fdsT] return $ "term_new(CTR, u12v2_new(" ++ show cid ++ ", " ++ show arity ++ "), " ++ ctrName ++ ")" compileCore book (Mat val css) host = do uid <- fresh let matName = "mat" ++ show uid let arity = length css emit $ " Loc " ++ matName ++ " = alloc_node(" ++ show (1 + arity) ++ ");" valT <- compileCore book val (matName ++ " + 0") emit $ " set(" ++ matName ++ " + 0, " ++ valT ++ ");" cssT <- mapM (\ (i,cs) -> compileCore book cs (matName ++ " + " ++ show (i+1))) (zip [0..] css) sequence_ [emit $ " set(" ++ matName ++ " + " ++ show (i+1) ++ ", " ++ csT ++ ");" | (i,csT) <- zip [0..] cssT] return $ "term_new(MAT, " ++ show arity ++ ", " ++ matName ++ ")" compileCore book (U32 val) _ = return $ "term_new(W32, 0, " ++ show (fromIntegral val) ++ ")" compileCore book (Op2 opr nm0 nm1) host = do uid <- fresh let opxName = "opx" ++ show uid emit $ " Loc " ++ opxName ++ " = alloc_node(2);" nm0T <- compileCore book nm0 (opxName ++ " + 0") nm1T <- compileCore book nm1 (opxName ++ " + 1") emit $ " set(" ++ opxName ++ " + 0, " ++ nm0T ++ ");" emit $ " set(" ++ opxName ++ " + 1, " ++ nm1T ++ ");" return $ "term_new(OPX, " ++ show (fromEnum opr) ++ ", " ++ opxName ++ ")" compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #60: -- Type.hs: -- //./Type.hs// #61: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #62: module Main where #63: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #64: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #65: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #66: -- Main -- ---- #67: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #68: -- CLI Commands -- ------------ #69: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #70: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #71: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #72: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #73: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #74: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #75: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #76: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root norm <- doExtractCore done putStrLn $ coreToString norm #77: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #78: -- Finalize hvmFree return $ Right () #79: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #80: -- //./Runtime.c// #81: module HVML.Type where #82: import Data.Map.Strict as MS import Data.Word import Foreign.Ptr #83: -- Core Types -- ---------- #84: -- NOTE TO AI: we're now adding the uint32 type, including: -- - U32: uint32 value, like '42' -- - OPX: uint32 binary operation, like 'add', 'mul', etc. -- Your goal is to add the uint32 funcionality to each file. #85: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] | U32 Word32 | Op2 Oper Core Core deriving (Show, Eq) #86: data Oper = OP_ADD | OP_SUB | OP_MUL | OP_DIV | OP_MOD | OP_EQ | OP_NE | OP_LT | OP_GT | OP_LTE | OP_GTE | OP_AND | OP_OR | OP_XOR | OP_LSH | OP_RSH deriving (Show, Eq, Enum) #87: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #88: -- Runtime Types -- ------------- #89: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #90: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT | W32 | OPX | OPY deriving (Eq, Show) #91: type HVM = IO #92: -- C Functions -- ----------- #93: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #94: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #95: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #96: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #97: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #98: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #99: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #100: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #101: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #102: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #103: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #104: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #105: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #106: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #107: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #108: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #109: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #110: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #111: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #112: foreign import ccall unsafe "Runtime.c reduce_app_w32" reduceAppW32 :: Term -> Term -> IO Term #113: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #114: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #115: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #116: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #117: foreign import ccall unsafe "Runtime.c reduce_dup_w32" reduceDupW32 :: Term -> Term -> IO Term #118: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #119: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #120: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #121: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #122: foreign import ccall unsafe "Runtime.c reduce_mat_w32" reduceMatW32 :: Term -> Term -> IO Term #123: foreign import ccall unsafe "Runtime.c reduce_opx_era" reduceOpxEra :: Term -> Term -> IO Term #124: foreign import ccall unsafe "Runtime.c reduce_opx_lam" reduceOpxLam :: Term -> Term -> IO Term #125: foreign import ccall unsafe "Runtime.c reduce_opx_sup" reduceOpxSup :: Term -> Term -> IO Term #126: foreign import ccall unsafe "Runtime.c reduce_opx_ctr" reduceOpxCtr :: Term -> Term -> IO Term #127: foreign import ccall unsafe "Runtime.c reduce_opx_w32" reduceOpxW32 :: Term -> Term -> IO Term #128: foreign import ccall unsafe "Runtime.c reduce_opy_era" reduceOpyEra :: Term -> Term -> IO Term #129: foreign import ccall unsafe "Runtime.c reduce_opy_lam" reduceOpyLam :: Term -> Term -> IO Term #130: foreign import ccall unsafe "Runtime.c reduce_opy_sup" reduceOpySup :: Term -> Term -> IO Term #131: foreign import ccall unsafe "Runtime.c reduce_opy_ctr" reduceOpyCtr :: Term -> Term -> IO Term #132: foreign import ccall unsafe "Runtime.c reduce_opy_w32" reduceOpyW32 :: Term -> Term -> IO Term #133: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #134: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #135: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #136: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #137: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #138: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #139: -- Constants -- --------- #140: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT 0x0B = W32 tagT 0x0C = OPX tagT 0x0D = OPY tagT tag = error $ "unknown tag" ++ show tag #141: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_, _W32_, _OPX_, _OPY_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A _W32_ = 0x0B _OPX_ = 0x0C _OPY_ = 0x0D ./Runtime.c #142: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #143: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint32_t u32; typedef uint64_t u64; #144: typedef _Atomic(Term) ATerm; #145: // Runtime Types // ------------- #146: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #147: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #148: // Constants // --------- #149: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #define W32 0x0B #define OPX 0x0C #define OPY 0x0D #150: #define OP_ADD 0x00 #define OP_SUB 0x01 #define OP_MUL 0x02 #define OP_DIV 0x03 #define OP_MOD 0x04 #define OP_EQ 0x05 #define OP_NE 0x06 #define OP_LT 0x07 #define OP_GT 0x08 #define OP_LTE 0x09 #define OP_GTE 0x0A #define OP_AND 0x0B #define OP_OR 0x0C #define OP_XOR 0x0D #define OP_LSH 0x0E #define OP_RSH 0x0F #151: #define VOID 0x00000000000000 #152: // Heap // ---- #153: Loc get_len() { return *HVM.size; } #154: Loc get_itr() { return *HVM.itrs; } #155: void set_len(Loc value) { *HVM.size = value; } #156: void set_itr(Loc value) { *HVM.itrs = value; } #157: // Terms // ------ #158: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #159: Tag term_tag(Term x) { return x & 0xFF; } #160: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #161: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #162: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #163: // u12v2 // ----- #164: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #165: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #166: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #167: // Atomics // ------- #168: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #169: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #170: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #171: Term take(Loc loc) { return swap(loc, VOID); } #172: // Allocation // ---------- #173: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #174: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #175: // Stringification // --------------- #176: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #177: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #178: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #179: // Evaluation // ---------- #180: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #181: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #182: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #183: // (&L{a b} c) // ----------------- APP-SUP // ! &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #184: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #185: // (123 a) // ------- APP-W32 // ⊥ Term reduce_app_w32(Term app, Term w32) { printf("invalid:app-w32"); exit(0); } #186: // ! &L{x y} = * // ------------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #187: // ! &L{r s} = λx(f) // ----------------- DUP-LAM // ! &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #188: // ! &L{x y} = &R{a b} // ------------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // ! &L{a0 a1} = a // ! &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #189: // ! &{x y} = #{a b c ...} // ----------------------- DUP-CTR // ! &{a0 a1} = a // ! &{b0 b1} = b // ! &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #190: // ! &L{x y} = 123 // --------------- DUP-W32 // x <- 123 // y <- 123 Term reduce_dup_w32(Term dup, Term w32) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, w32); set(dup_loc + 1, w32); return got(dup_loc + dup_num); } #191: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #192: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #193: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // ! &{k0a k0b} = K0 // ! &{k1a k1b} = K1 // ! &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #194: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #195: // ~ num {K0 K1 K2 ... KN} // ----------------------- MAT-W32 // if n < N: Kn // else : KN(num-N) Term reduce_mat_w32(Term mat, Term w32) { inc_itr(); Loc mat_loc = term_loc(mat); Lab mat_len = term_lab(mat); u64 w32_val = term_loc(w32); if (w32_val < mat_len - 1) { return got(mat_loc + 1 + w32_val); } else { Loc app = alloc_node(2); set(app + 0, got(mat_loc + mat_len)); set(app + 1, term_new(W32, 0, w32_val - (mat_len - 1))); return term_new(APP, 0, app); } } #196: // TODO: now, let's implement the missing OPX interactions. #197: // <op(* b) // --------- OPX-ERA // * Term reduce_opx_era(Term opx, Term era) { inc_itr(); return era; } #198: // <op(λx(B) y) // ------------- OPX-LAM // ⊥ Term reduce_opx_lam(Term opx, Term lam) { printf("invalid:opx-lam"); exit(0); } #199: // <op(&L{x0 x1} y) // ------------------------- OPX-SUP // ! &L{y0 y1} = y // &L{<op(x0 y0) <op(x1 y1)} Term reduce_opx_sup(Term opx, Term sup) { inc_itr(); Loc opx_loc = term_loc(opx); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmy = got(opx_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, nmy); set(op0 + 0, tm0); set(op0 + 1, term_new(DP0, 0, du0)); set(op1 + 0, tm1); set(op1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(OPX, term_lab(opx), op0)); set(su0 + 1, term_new(OPX, term_lab(opx), op1)); return term_new(SUP, sup_lab, su0); } #200: // <op(#{x0 x1 x2...} y) // ---------------------- OPX-CTR // ⊥ Term reduce_opx_ctr(Term opx, Term ctr) { printf("invalid:opx-ctr"); exit(0); } #201: // <op(x0 x1) // ----------- OPX-W32 // <op(x0 x1) Term reduce_opx_w32(Term opx, Term w32) { inc_itr(); Lab opx_lab = term_lab(opx); Lab opx_loc = term_loc(opx); return term_new(OPY, opx_lab, opx_loc); } #202: // >op(a *) // --------- OPY-ERA // * Term reduce_opy_era(Term opy, Term era) { inc_itr(); return era; } #203: // >op(a λx(B)) // ------------- OPY-LAM // * Term reduce_opy_lam(Term opy, Term era) { printf("invalid:opy-lam"); exit(0); } #204: // >op(a &L{x y}) // ------------------------- OPY-SUP // &L{>op(a x) >op(a y)} Term reduce_opy_sup(Term opy, Term sup) { inc_itr(); Loc opy_loc = term_loc(opy); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term nmx = got(opy_loc + 0); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc op0 = alloc_node(2); Loc op1 = alloc_node(2); Loc su0 = alloc_node(2); set(op0 + 0, nmx); set(op0 + 1, tm0); set(op1 + 0, nmx); set(op1 + 1, tm1); set(su0 + 0, term_new(OPY, term_lab(opy), op0)); set(su0 + 1, term_new(OPY, term_lab(opy), op1)); return term_new(SUP, sup_lab, su0); } #205: // >op(#{x y z ...} b) // ---------------------- OPY-CTR // ⊥ Term reduce_opy_ctr(Term opy, Term ctr) { printf("invalid:opy-ctr"); exit(0); } #206: // >op(x y) // --------- OPY-W32 // x op y Term reduce_opy_w32(Term opy, Term w32) { inc_itr(); Loc opy_loc = term_loc(opy); u32 x = term_loc(got(opy_loc + 0)); u32 y = term_loc(w32); u32 result; switch (term_lab(opy)) { case OP_ADD: result = x + y; break; case OP_SUB: result = x - y; break; case OP_MUL: result = x * y; break; case OP_DIV: result = x / y; break; case OP_MOD: result = x % y; break; case OP_EQ: result = x == y; break; case OP_NE: result = x != y; break; case OP_LT: result = x < y; break; case OP_GT: result = x > y; break; case OP_LTE: result = x <= y; break; case OP_GTE: result = x >= y; break; case OP_AND: result = x & y; break; case OP_OR: result = x | y; break; case OP_XOR: result = x ^ y; break; case OP_LSH: result = x << y; break; case OP_RSH: result = x >> y; break; default: result = 0; } return term_new(W32, 0, result); } #207: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPX: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case OPY: { HVM.path[spos++] = next; next = got(loc + 1); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; case W32: next = reduce_app_w32(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; case W32: next = reduce_dup_w32(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); continue; case LAM: next = reduce_mat_lam(prev, next); continue; case SUP: next = reduce_mat_sup(prev, next); continue; case CTR: next = reduce_mat_ctr(prev, next); continue; case W32: next = reduce_mat_w32(prev, next); continue; default: break; } } case OPX: { switch (tag) { case ERA: next = reduce_opx_era(prev, next); continue; case LAM: next = reduce_opx_lam(prev, next); continue; case SUP: next = reduce_opx_sup(prev, next); continue; case CTR: next = reduce_opx_ctr(prev, next); continue; case W32: next = reduce_opx_w32(prev, next); continue; default: break; } } case OPY: { switch (tag) { case ERA: next = reduce_opy_era(prev, next); continue; case LAM: next = reduce_opy_lam(prev, next); continue; case SUP: next = reduce_opy_sup(prev, next); continue; case CTR: next = reduce_opy_ctr(prev, next); continue; case W32: next = reduce_opy_w32(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #208: // Runtime Memory // -------------- #209: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #210: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #211: State* hvm_get_state() { return &HVM; } #212: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #213: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #214: // Main // ---- #215: //#include "book.c" #216: //int main() { //hvm_init(); //inject_P24(); #217: //clock_t start = clock(); #218: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #219: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #220: //hvm_free(); //return 0; //} ./Extract.hs #221: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// #222: module HVML.Extract where #223: import Control.Monad (foldM) import HVML.Type import qualified Data.IntSet as IS #224: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> do return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term let lab = termLab term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup lab tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp1)) else extractCore sub dups CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0..ari-1] (dups0, fds) <- foldM (\ (dups,fds) fd -> do (dups0, fd0) <- extractCore fd dups return (dups0, fds ++ [fd0])) (dups,[]) fds return (dups0, Ctr cid fds) MAT -> do let loc = termLoc term let ari = termLab term val <- got (loc + 0) css <- if ari == 0 then return [] else mapM (\i -> got (loc + 1 + i)) [0..ari-1] (dups0, val0) <- extractCore val dups (dups1, css0) <- foldM (\ (dups,css) cs -> do (dups0, cs0) <- extractCore cs dups return (dups0, css ++ [cs0])) (dups0,[]) css return (dups1, Mat val0 css0) W32 -> do let val = termLoc term return (dups, U32 (fromIntegral val)) OPX -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- got (loc + 0) nm1 <- got (loc + 1) (dups0, nm00) <- extractCore nm0 dups (dups1, nm10) <- extractCore nm1 dups0 return (dups1, Op2 opr nm00 nm10) OPY -> do let loc = termLoc term let opr = toEnum (fromIntegral (termLab term)) nm0 <- got (loc + 0) nm1 <- got (loc + 1) (dups0, nm00) <- extractCore nm0 dups (dups1, nm10) <- extractCore nm1 dups0 return (dups1, Op2 opr nm00 nm10) REF -> do let loc = termLoc term return (dups, Ref "?" loc) _ -> do return (dups, Era) #225: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #226: -- //./Type.hs// #227: module HVML.Inject where #228: import Control.Monad (foldM) import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #229: type VarMap = IM.IntMap (Maybe Term) #230: injectCore :: Book -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore book (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore book bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore book (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore book fun (app + 0) vars vars1 <- injectCore book arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore book (Sup lab tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore book tm0 (sup + 0) vars vars1 <- injectCore book tm1 (sup + 1) vars0 set loc (termNew _SUP_ lab sup) return vars1 injectCore book (Dup lab dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ lab dup) vars vars1 <- injectBind dp1 (termNew _DP1_ lab dup) vars0 vars2 <- injectCore book val (dup + 2) vars1 injectCore book bod loc vars2 injectCore book (Ref nam fid) loc vars = do set loc (termNew _REF_ 0 fid) return vars injectCore book (Ctr cid fds) loc vars = do let arity = length fds ctr <- allocNode (fromIntegral arity) vars0 <- foldM (\vs (ix,fd) -> injectCore book fd (ctr + ix) vs) vars (zip [0..] fds) set loc (termNew _CTR_ (u12v2New cid (fromIntegral (length fds))) ctr) return vars0 injectCore book (Mat val css) loc vars = do mat <- allocNode (1 + fromIntegral (length css)) vars0 <- injectCore book val (mat + 0) vars vars1 <- foldM (\vs (ix,bod) -> do injectCore book bod (mat + 1 + ix) vs) vars0 (zip [0..] css) set loc (termNew _MAT_ (fromIntegral (length css)) mat) return vars1 injectCore book (U32 val) loc vars = do set loc (termNew _W32_ 0 (fromIntegral val)) return vars injectCore book (Op2 opr nm0 nm1) loc vars = do opx <- allocNode 2 vars0 <- injectCore book nm0 (opx + 0) vars vars1 <- injectCore book nm1 (opx + 1) vars0 set loc (termNew _OPX_ (fromIntegral $ fromEnum opr) opx) return vars1 injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #231: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #232: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do injectCore book core 0 IM.empty got 0

2853d07aa03b00a987ed501b7713785eca231a07

DUP/SUP labels, better parse error messages

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = "x" ++ nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λx" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup tm0 tm1) = "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup dp0 dp1 val bod) = "&{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" #6: -- Runtime Stringification -- ----------------------- #7: tagToString :: Tag -> String tagToString t = show (tagT t) #8: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #9: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #10: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #11: -- Dumping -- ------- #12: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #13: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #14: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #15: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #16: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #17: -- //./Type.hs// -- //./Show.hs// #18: module HVML.Parse where #19: import Data.Word import HVML.Show import HVML.Type import Text.Parsec hiding (State) import Text.Parsec.String import qualified Data.Map.Strict as MS #20: import Debug.Trace #21: parseCore :: Parser Core parseCore = do spaces head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '{' -> do consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup tm0 tm1 '&' -> do consume "&" consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName return $ Var name #22: parseName :: Parser String parseName = spaces >> many1 (alphaNum <|> char '_') #23: parseDef :: Parser (String, Core) parseDef = do try $ do spaces consume "@" name <- parseName spaces consume "=" core <- parseCore return (name, core) #24: parseBook :: Parser [(String, Core)] parseBook = do spaces many parseDef #25: doParseCore :: String -> Core doParseCore code = case parse parseCore "" code of Right core -> core Left _ -> Era #26: doParseBook :: String -> Book doParseBook code = case parse parseBook "" code of Right defs -> createBook defs Left _ -> Book MS.empty MS.empty MS.empty #27: consume :: String -> Parser String consume str = spaces >> string str #28: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #29: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #30: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup x y -> Sup (decorateFnIds fids x) (decorateFnIds fids y) Dup x y v b -> Dup x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other ./Compile.hs #31: -- //./Type.hs// #32: module HVML.Compile where #33: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #34: -- Compilation -- ----------- #35: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #36: type Compile = State CompileState #37: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #38: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #39: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #40: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #41: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #42: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, 0, " ++ supName ++ ")" compileCore book (Dup dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, 0, " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, 0, " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #43: -- Type.hs: -- //./Type.hs// #44: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #45: module Main where #46: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #47: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Normal import HVML.Parse import HVML.Show import HVML.Type #48: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #49: -- Main -- ---- #50: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #51: -- CLI Commands -- ------------ #52: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #53: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath let book = doParseBook code #54: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #55: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #56: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #57: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #58: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root norm <- doExtractCore done putStrLn $ coreToString norm #59: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #60: -- Finalize hvmFree return $ Right () #61: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Normal.hs #62: -- //./Type.hs// #63: module HVML.Normal where #64: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #65: import Debug.Trace #66: -- debug a b = trace a b debug a b = b #67: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) fun <- reduce book fun case tagT (termTag fun) of ERA -> reduceAppEra term fun >>= reduce book LAM -> reduceAppLam term fun >>= reduce book SUP -> reduceAppSup term fun >>= reduce book CTR -> reduceAppCtr term fun >>= reduce book _ -> set (loc + 0) fun >> return term DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do val <- got (loc + 2) val <- reduce book val case tagT (termTag val) of ERA -> reduceDupEra term val >>= reduce book LAM -> reduceDupLam term val >>= reduce book SUP -> reduceDupSup term val >>= reduce book CTR -> reduceDupCtr term val >>= reduce book _ -> set (loc + 2) val >> return term else do reduce book sub MAT -> do val <- got (loc + 0) val <- reduce book val case tagT (termTag val) of ERA -> reduceMatEra term val >>= reduce book LAM -> reduceMatLam term val >>= reduce book SUP -> reduceMatSup term val >>= reduce book CTR -> reduceMatCtr term val >>= reduce book _ -> set (loc + 0) val >> return term VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ term else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #68: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = debug ("NORM: " ++ termToString term) $ do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf -- TODO: implement the normalizer rules for CTR and MAT -- CTR -> do -- args <- mapM (\i -> got (loc + i)) [0..termLab wnf - 1] -- args <- mapM (normalizer reducer book) args -- mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args -- return wnf -- MAT -> do -- args <- mapM (\x -> got (loc + i)) [0..termLab wnf] -- args <- mapM (normalizer reducer book) args -- mapM_ (\ (i, arg) -> set (loc + i) arg) $ zip [0..] args -- return wnf _ -> do return wnf #69: normal :: Book -> Term -> HVM Term normal = normalizer reduce #70: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Type.hs #71: -- //./Runtime.c// #72: module HVML.Type where #73: import Data.Word import Data.Map.Strict as MS import Foreign.Ptr #74: -- Core Types -- ---------- #75: data Core = Var String | Era | Lam String Core | App Core Core | Sup Core Core | Dup String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] deriving (Show, Eq) #76: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #77: -- Runtime Types -- ------------- #78: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #79: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT deriving (Eq, Show) #80: type HVM = IO #81: -- C Functions -- ----------- #82: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #83: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #84: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #85: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #86: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #87: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #88: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #89: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #90: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #91: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #92: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #93: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #94: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #95: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #96: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #97: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #98: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #99: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #100: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #101: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #102: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #103: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #104: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #105: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #106: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #107: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #108: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #109: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #110: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #111: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #112: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #113: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #114: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #115: -- Constants -- --------- #116: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT tag = error $ "unknown tag" ++ show tag #117: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A ./Runtime.c #118: //./Type.hs// //./Inject.hs// #119: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #120: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint64_t u64; #121: typedef _Atomic(Term) ATerm; #122: // Runtime Types // ------------- #123: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #124: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #125: // Constants // --------- #126: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #127: #define VOID 0x00000000000000 #128: // Heap // ---- #129: Loc get_len() { return *HVM.size; } #130: Loc get_itr() { return *HVM.itrs; } #131: void set_len(Loc value) { *HVM.size = value; } #132: void set_itr(Loc value) { *HVM.itrs = value; } #133: // Terms // ------ #134: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #135: Tag term_tag(Term x) { return x & 0xFF; } #136: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #137: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #138: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #139: // u12v2 // ----- #140: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #141: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #142: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #143: // Atomics // ------- #144: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #145: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #146: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #147: Term take(Loc loc) { return swap(loc, VOID); } #148: // Allocation // ---------- #149: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #150: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #151: // Stringification // --------------- #152: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #153: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #154: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #155: // Evaluation // ---------- #156: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #157: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #158: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #159: // ({a b} c) // --------------- APP-SUP // &{x0 x1} = c // {(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, 0, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, 0, su0); } #160: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #161: // &{x y} = * // ---------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #162: // &{r s} = λx(f) // -------------- DUP-LAM // &{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- {x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, 0, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, 0, su0)); return got(dup_loc + dup_num); } #163: // &{x y} = {a b} // -------------- DUP-SUP // x <- a // y <- b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } #164: // &{x y} = #{a b c ...} // --------------------- DUP-CTR // &{a0 a1} = a // &{b0 b1} = b // &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #165: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #166: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #167: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // &{k0a k0b} = K0 // &{k1a k1b} = K1 // &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #168: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #169: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); exit(0); case LAM: next = reduce_mat_lam(prev, next); exit(0); case SUP: next = reduce_mat_sup(prev, next); exit(0); case CTR: next = reduce_mat_ctr(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #170: //Term normal(Term term) { //Term wnf = reduce(term); //Tag tag = term_tag(wnf); //Lab lab = term_lab(wnf); //Loc loc = term_loc(wnf); //switch (tag) { //case APP: { //Term fun; //Term arg; //fun = got(loc + 0); //fun = normal(fun); //arg = got(loc + 1); //arg = normal(arg); //set(loc + 0, fun); //set(loc + 1, arg); //return wnf; //} //case LAM: { //Term bod; //bod = got(loc + 1); //bod = normal(bod); //set(loc + 1, bod); //return wnf; //} //case SUP: { //Term tm0; //Term tm1; //tm0 = got(loc + 0); //tm0 = normal(tm0); //tm1 = got(loc + 1); //tm1 = normal(tm1); //set(loc + 0, tm0); //set(loc + 1, tm1); //return wnf; //} //case DP0: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //case DP1: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //default: //return wnf; //} //} #171: // Runtime Memory // -------------- #172: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #173: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #174: // TODO: create an hvm_get and an hvm_set function that get/set the whole HVM struct State* hvm_get_state() { return &HVM; } #175: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #176: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #177: // Main // ---- #178: //#include "book.c" #179: //int main() { //hvm_init(); //inject_P24(); #180: //clock_t start = clock(); #181: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #182: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #183: //hvm_free(); //return 0; //} ./Extract.hs #184: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// #185: module HVML.Extract where #186: import Control.Monad (foldM) import HVML.Type import qualified Data.IntSet as IS #187: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp1)) else extractCore sub dups CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0..ari-1] (dups0, fds) <- foldM (\ (dups,fds) fd -> do (dups0, fd0) <- extractCore fd dups return (dups0, fds ++ [fd0])) (dups,[]) fds return (dups0, Ctr cid fds) MAT -> do let loc = termLoc term let ari = termLab term val <- got (loc + 0) css <- if ari == 0 then return [] else mapM (\i -> got (loc + 1 + i)) [0..ari-1] (dups0, val0) <- extractCore val dups (dups1, css0) <- foldM (\ (dups,css) cs -> do (dups0, cs0) <- extractCore cs dups return (dups0, css ++ [cs0])) (dups0,[]) css return (dups1, Mat val0 css0) REF -> do let loc = termLoc term return (dups, Ref "?" loc) _ -> do return (dups, Era) #188: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #189: -- //./Type.hs// #190: module HVML.Inject where #191: import Control.Monad (foldM) import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #192: type VarMap = IM.IntMap (Maybe Term) #193: injectCore :: Book -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore book (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore book bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore book (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore book fun (app + 0) vars vars1 <- injectCore book arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore book (Sup tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore book tm0 (sup + 0) vars vars1 <- injectCore book tm1 (sup + 1) vars0 set loc (termNew _SUP_ 0 sup) return vars1 injectCore book (Dup dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ 0 dup) vars vars1 <- injectBind dp1 (termNew _DP1_ 0 dup) vars0 vars2 <- injectCore book val (dup + 2) vars1 injectCore book bod loc vars2 injectCore book (Ref nam fid) loc vars = do set loc (termNew _REF_ 0 fid) return vars injectCore book (Ctr cid fds) loc vars = do let arity = length fds ctr <- allocNode (fromIntegral arity) vars0 <- foldM (\vs (ix,fd) -> injectCore book fd (ctr + ix) vs) vars (zip [0..] fds) set loc (termNew _CTR_ (u12v2New cid (fromIntegral (length fds))) ctr) return vars0 injectCore book (Mat val css) loc vars = do mat <- allocNode (1 + fromIntegral (length css)) vars0 <- injectCore book val (mat + 0) vars vars1 <- foldM (\vs (ix,bod) -> do injectCore book bod (mat + 1 + ix) vs) vars0 (zip [0..] css) set loc (termNew _MAT_ (fromIntegral (length css)) mat) return vars1 injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #194: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #195: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do injectCore book core 0 IM.empty got 0

./Show.hs #1: -- //./Type.hs// #2: module HVML.Show where #3: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #4: -- Core Stringification -- -------------------- #5: coreToString :: Core -> String coreToString (Var nam) = "x" ++ nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λx" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup lab tm0 tm1) = "&" ++ show lab ++ "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup lab dp0 dp1 val bod) = "! &" ++ show lab ++ "{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam coreToString (Ctr cid fds) = "#" ++ show cid ++ "{" ++ unwords (map coreToString fds) ++ "}" coreToString (Mat val css) = "~" ++ coreToString val ++ "{" ++ unwords (map coreToString css) ++ "}" #6: -- Runtime Stringification -- ----------------------- #7: tagToString :: Tag -> String tagToString t = show (tagT t) #8: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #9: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #10: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #11: -- Dumping -- ------- #12: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #13: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #14: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #15: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #16: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #17: -- //./Type.hs// #18: module HVML.Parse where #19: import Data.List import Data.Maybe import Data.Word import Debug.Trace import HVML.Show import HVML.Type import Highlight (highlightError) import System.Console.ANSI import Text.Parsec hiding (State) import Text.Parsec.Error import Text.Parsec.Pos import Text.Parsec.String import qualified Data.Map.Strict as MS #20: -- Core Parsers -- ------------ #21: parseCore :: Parser Core parseCore = do skip head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '&' -> do consume "&" lab <- read <$> many1 digit consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup lab tm0 tm1 '!' -> do consume "!" consume "&" lab <- read <$> many1 digit consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup lab dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 '#' -> do consume "#" cid <- read <$> many1 digit consume "{" fds <- many $ do closeWith "}" parseCore consume "}" return $ Ctr cid fds '~' -> do consume "~" val <- parseCore consume "{" css <- many $ do closeWith "}" parseCore consume "}" return $ Mat val css _ -> do name <- parseName return $ Var name #22: parseName :: Parser String parseName = skip >> many1 (alphaNum <|> char '_') #23: parseDef :: Parser (String, Core) parseDef = do try $ do skip consume "@" name <- parseName skip consume "=" core <- parseCore return (name, core) #24: parseBook :: Parser [(String, Core)] parseBook = do skip defs <- many parseDef skip eof return defs #25: doParseCore :: String -> IO Core doParseCore code = case parse parseCore "" code of Right core -> return $ core Left err -> do showParseError "" code err return $ Ref "⊥" 0 #26: doParseBook :: String -> IO Book doParseBook code = case parse parseBook "" code of Right defs -> return $ createBook defs Left err -> do showParseError "" code err return $ Book MS.empty MS.empty MS.empty #27: -- Helper Parsers -- -------------- #28: consume :: String -> Parser String consume str = spaces >> string str #29: closeWith :: String -> Parser () closeWith str = try $ do spaces notFollowedBy (string str) #30: skip :: Parser () skip = skipMany (parseSpace <|> parseComment) where parseSpace = (try $ do space return ()) <?> "space" parseComment = (try $ do string "//" skipMany (noneOf "\n") char '\n' return ()) <?> "Comment" #31: -- Adjusting -- --------- #32: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #33: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup l x y -> Sup l (decorateFnIds fids x) (decorateFnIds fids y) Dup l x y v b -> Dup l x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other #34: -- Errors -- ------ #35: -- Error handling extractExpectedTokens :: ParseError -> String extractExpectedTokens err = let expectedMsgs = [msg | Expect msg <- errorMessages err, msg /= "space", msg /= "Comment"] in intercalate " | " expectedMsgs #36: showParseError :: String -> String -> ParseError -> IO () showParseError filename input err = do let pos = errorPos err let lin = sourceLine pos let col = sourceColumn pos let errorMsg = extractExpectedTokens err putStrLn $ setSGRCode [SetConsoleIntensity BoldIntensity] ++ "\nPARSE_ERROR" ++ setSGRCode [Reset] putStrLn $ "- expected: " ++ errorMsg putStrLn $ "- detected:" putStrLn $ highlightError (lin, col) (lin, col + 1) input putStrLn $ setSGRCode [SetUnderlining SingleUnderline] ++ filename ++ setSGRCode [Reset] ./Compile.hs #37: -- //./Type.hs// #38: module HVML.Compile where #39: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #40: -- Compilation -- ----------- #41: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #42: type Compile = State CompileState #43: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #44: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #45: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #46: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #47: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #48: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup lab tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, " ++ show lab ++ ", " ++ supName ++ ")" compileCore book (Dup lab dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, " ++ show lab ++ ", " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, " ++ show lab ++ ", " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #49: -- Type.hs: -- //./Type.hs// #50: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #51: module Main where #52: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #53: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Parse import HVML.Reduce import HVML.Show import HVML.Type #54: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #55: -- Main -- ---- #56: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #57: -- CLI Commands -- ------------ #58: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #59: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath book <- doParseBook code #60: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #61: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #62: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #63: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #64: -- Abort when main isn't present when (not $ MS.member "main" (nameToId book)) $ do putStrLn "Error: 'main' not found." exitWith (ExitFailure 1) #65: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") -- norm <- doExtractCore root done <- (if compiled then normalC else normal) book root norm <- doExtractCore done putStrLn $ coreToString norm #66: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #67: -- Finalize hvmFree return $ Right () #68: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Type.hs #69: -- //./Runtime.c// #70: module HVML.Type where #71: import Data.Word import Data.Map.Strict as MS import Foreign.Ptr #72: -- Core Types -- ---------- #73: -- REFACTOR NOTE: we just added a Word64 field to Sup/Dup. it is called 'lab'. #74: data Core = Var String | Era | Lam String Core | App Core Core | Sup Word64 Core Core | Dup Word64 String String Core Core | Ref String Word64 | Ctr Word64 [Core] | Mat Core [Core] deriving (Show, Eq) #75: data Book = Book { idToCore :: MS.Map Word64 Core , idToName :: MS.Map Word64 String , nameToId :: MS.Map String Word64 } deriving (Show, Eq) #76: -- Runtime Types -- ------------- #77: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #78: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF | CTR | MAT deriving (Eq, Show) #79: type HVM = IO #80: -- C Functions -- ----------- #81: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #82: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #83: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #84: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #85: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #86: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #87: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #88: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #89: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #90: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #91: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #92: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #93: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #94: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #95: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #96: foreign import ccall unsafe "Runtime.c reduce_app_era" reduceAppEra :: Term -> Term -> IO Term #97: foreign import ccall unsafe "Runtime.c reduce_app_lam" reduceAppLam :: Term -> Term -> IO Term #98: foreign import ccall unsafe "Runtime.c reduce_app_sup" reduceAppSup :: Term -> Term -> IO Term #99: foreign import ccall unsafe "Runtime.c reduce_app_ctr" reduceAppCtr :: Term -> Term -> IO Term #100: foreign import ccall unsafe "Runtime.c reduce_dup_era" reduceDupEra :: Term -> Term -> IO Term #101: foreign import ccall unsafe "Runtime.c reduce_dup_lam" reduceDupLam :: Term -> Term -> IO Term #102: foreign import ccall unsafe "Runtime.c reduce_dup_sup" reduceDupSup :: Term -> Term -> IO Term #103: foreign import ccall unsafe "Runtime.c reduce_dup_ctr" reduceDupCtr :: Term -> Term -> IO Term #104: foreign import ccall unsafe "Runtime.c reduce_mat_era" reduceMatEra :: Term -> Term -> IO Term #105: foreign import ccall unsafe "Runtime.c reduce_mat_lam" reduceMatLam :: Term -> Term -> IO Term #106: foreign import ccall unsafe "Runtime.c reduce_mat_sup" reduceMatSup :: Term -> Term -> IO Term #107: foreign import ccall unsafe "Runtime.c reduce_mat_ctr" reduceMatCtr :: Term -> Term -> IO Term #108: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #109: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #110: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #111: foreign import ccall unsafe "Runtime.c u12v2_new" u12v2New :: Word64 -> Word64 -> Word64 #112: foreign import ccall unsafe "Runtime.c u12v2_x" u12v2X :: Word64 -> Word64 #113: foreign import ccall unsafe "Runtime.c u12v2_y" u12v2Y :: Word64 -> Word64 #114: -- Constants -- --------- #115: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT 0x09 = CTR tagT 0x0A = MAT tagT tag = error $ "unknown tag" ++ show tag #116: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_, _CTR_, _MAT_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 _CTR_ = 0x09 _MAT_ = 0x0A ./Runtime.c #117: //./Type.hs// //./Inject.hs// #118: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #119: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint64_t u64; #120: typedef _Atomic(Term) ATerm; #121: // Runtime Types // ------------- #122: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #123: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #124: // Constants // --------- #125: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #define CTR 0x09 #define MAT 0x0A #126: #define VOID 0x00000000000000 #127: // Heap // ---- #128: Loc get_len() { return *HVM.size; } #129: Loc get_itr() { return *HVM.itrs; } #130: void set_len(Loc value) { *HVM.size = value; } #131: void set_itr(Loc value) { *HVM.itrs = value; } #132: // Terms // ------ #133: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #134: Tag term_tag(Term x) { return x & 0xFF; } #135: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #136: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #137: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #138: // u12v2 // ----- #139: u64 u12v2_new(u64 x, u64 y) { return (y << 12) | x; } #140: u64 u12v2_x(u64 u12v2) { return u12v2 & 0x3FF; } #141: u64 u12v2_y(u64 u12v2) { return u12v2 >> 12; } #142: // Atomics // ------- #143: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #144: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #145: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #146: Term take(Loc loc) { return swap(loc, VOID); } #147: // Allocation // ---------- #148: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #149: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #150: // Stringification // --------------- #151: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; case CTR: printf("CTR"); break; case MAT: printf("MAT"); break; default : printf("???"); break; } } #152: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #153: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #154: // Evaluation // ---------- #155: // @foo // --------- REF // book[foo] Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #156: // (* a) // ----- APP-ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #157: // (λx(body) a) // ------------ APP-LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #158: // (&L{a b} c) // ----------------- APP-SUP // &L{x0 x1} = c // &L{(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Lab sup_lab = term_lab(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, sup_lab, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, sup_lab, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, sup_lab, su0); } #159: // (#{x y z ...} a) // ---------------- APP-CTR // ⊥ Term reduce_app_ctr(Term app, Term ctr) { printf("invalid:app-ctr"); exit(0); } #160: // &L{x y} = * // ----------- DUP-ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #161: // &L{r s} = λx(f) // --------------- DUP-LAM // &L{f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- &L{x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, dup_lab, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, dup_lab, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, dup_lab, su0)); return got(dup_loc + dup_num); } #162: // &L{x y} = &R{a b} // ----------------- DUP-SUP // if L == R: // x <- a // y <- b // else: // x <- &R{a0 b0} // y <- &R{a1 b1} // &L{a0 a1} = a // &L{b0 b1} = b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Lab dup_lab = term_lab(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Lab sup_lab = term_lab(sup); Loc sup_loc = term_loc(sup); if (dup_lab == sup_lab) { Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } else { Loc du0 = alloc_node(3); Loc du1 = alloc_node(3); Loc su0 = alloc_node(2); Loc su1 = alloc_node(2); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, tm0); set(du1 + 0, term_new(SUB, 0, 0)); set(du1 + 1, term_new(SUB, 0, 0)); set(du1 + 2, tm1); set(su0 + 0, term_new(DP0, dup_lab, du0)); set(su0 + 1, term_new(DP0, dup_lab, du1)); set(su1 + 0, term_new(DP1, dup_lab, du0)); set(su1 + 1, term_new(DP1, dup_lab, du1)); set(dup_loc + 0, term_new(SUP, sup_lab, su0)); set(dup_loc + 1, term_new(SUP, sup_lab, su1)); return got(dup_loc + dup_num); } } #163: // &{x y} = #{a b c ...} // --------------------- DUP-CTR // &{a0 a1} = a // &{b0 b1} = b // &{c0 c1} = c // ... // {#{a0 b0 c0 ...} #{a1 b1 c1 ...}} Term reduce_dup_ctr(Term dup, Term ctr) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_ari = u12v2_y(ctr_lab); Loc ctr0 = alloc_node(ctr_ari); Loc ctr1 = alloc_node(ctr_ari); for (u64 i = 0; i < ctr_ari; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(ctr_loc + i)); set(ctr0 + i, term_new(DP0, 0, du0)); set(ctr1 + i, term_new(DP1, 0, du0)); } Loc sup = alloc_node(2); set(sup + 0, term_new(CTR, ctr_lab, ctr0)); set(sup + 1, term_new(CTR, ctr_lab, ctr1)); set(dup_loc + 0, term_new(CTR, ctr_lab, ctr0)); set(dup_loc + 1, term_new(CTR, ctr_lab, ctr1)); return got(dup_loc + dup_num); } #164: // ~ * {K0 K1 K2 ...} // ------------------ MAT-ERA // * Term reduce_mat_era(Term mat, Term era) { inc_itr(); return era; } #165: // ~ λx(x) {K0 K1 K2 ...} // ---------------------- MAT-LAM // ⊥ Term reduce_mat_lam(Term mat, Term lam) { printf("invalid:mat-lam"); exit(0); } #166: // ~ {x y} {K0 K1 K2 ...} // ---------------------- MAT-SUP // &{k0a k0b} = K0 // &{k1a k1b} = K1 // &{k2a k2b} = K2 // ... // { ~ x {K0a K1a K2a ...} // ~ y {K0b K1b K2b ...} } Term reduce_mat_sup(Term mat, Term sup) { inc_itr(); Loc mat_loc = term_loc(mat); Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Lab mat_len = term_lab(mat); Loc sup0 = alloc_node(2); Loc mat0 = alloc_node(1 + mat_len); Loc mat1 = alloc_node(1 + mat_len); set(mat0 + 0, tm0); set(mat1 + 0, tm1); for (u64 i = 0; i < mat_len; i++) { Loc du0 = alloc_node(3); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, got(mat_loc + 1 + i)); set(mat0 + 1 + i, term_new(DP0, 0, du0)); set(mat1 + 1 + i, term_new(DP1, 0, du0)); } set(sup0 + 0, term_new(MAT, mat_len, mat0)); set(sup0 + 1, term_new(MAT, mat_len, mat1)); return term_new(SUP, 0, sup0); } #167: // ~ #N{x y z ...} {K0 K1 K2 ...} // ------------------------------ MAT-CTR // (((KN x) y) z ...) Term reduce_mat_ctr(Term mat, Term ctr) { inc_itr(); Loc mat_loc = term_loc(mat); Loc ctr_loc = term_loc(ctr); Lab ctr_lab = term_lab(ctr); u64 ctr_num = u12v2_x(ctr_lab); u64 ctr_ari = u12v2_y(ctr_lab); Term app = got(mat_loc + 1 + ctr_num); for (u64 i = 0; i < ctr_ari; i++) { Loc new_app = alloc_node(2); set(new_app + 0, app); set(new_app + 1, got(ctr_loc + i)); app = term_new(APP, 0, new_app); } return app; } #168: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("NEXT! "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case MAT: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; case CTR: next = reduce_app_ctr(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; case CTR: next = reduce_dup_ctr(prev, next); continue; default: break; } break; } case MAT: { switch (tag) { case ERA: next = reduce_mat_era(prev, next); exit(0); case LAM: next = reduce_mat_lam(prev, next); exit(0); case SUP: next = reduce_mat_sup(prev, next); exit(0); case CTR: next = reduce_mat_ctr(prev, next); continue; default: break; } } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; case MAT: set(hloc + 0, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #169: //Term normal(Term term) { //Term wnf = reduce(term); //Tag tag = term_tag(wnf); //Lab lab = term_lab(wnf); //Loc loc = term_loc(wnf); //switch (tag) { //case APP: { //Term fun; //Term arg; //fun = got(loc + 0); //fun = normal(fun); //arg = got(loc + 1); //arg = normal(arg); //set(loc + 0, fun); //set(loc + 1, arg); //return wnf; //} //case LAM: { //Term bod; //bod = got(loc + 1); //bod = normal(bod); //set(loc + 1, bod); //return wnf; //} //case SUP: { //Term tm0; //Term tm1; //tm0 = got(loc + 0); //tm0 = normal(tm0); //tm1 = got(loc + 1); //tm1 = normal(tm1); //set(loc + 0, tm0); //set(loc + 1, tm1); //return wnf; //} //case DP0: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //case DP1: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //default: //return wnf; //} //} #170: // Runtime Memory // -------------- #171: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #172: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #173: // TODO: create an hvm_get and an hvm_set function that get/set the whole HVM struct State* hvm_get_state() { return &HVM; } #174: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #175: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #176: // Main // ---- #177: //#include "book.c" #178: //int main() { //hvm_init(); //inject_P24(); #179: //clock_t start = clock(); #180: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #181: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #182: //hvm_free(); //return 0; //} ./Extract.hs #183: -- //./Type.hs// -- //./Show.hs// -- //./Inject.hs// #184: module HVML.Extract where #185: import Control.Monad (foldM) import HVML.Type import qualified Data.IntSet as IS #186: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> do return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term let lab = termLab term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup lab tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let lab = termLab term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup lab dp0 dp1 val0 (Var dp1)) else extractCore sub dups CTR -> do let loc = termLoc term let lab = termLab term let cid = u12v2X lab let ari = u12v2Y lab fds <- if ari == 0 then return [] else mapM (\i -> got (loc + i)) [0..ari-1] (dups0, fds) <- foldM (\ (dups,fds) fd -> do (dups0, fd0) <- extractCore fd dups return (dups0, fds ++ [fd0])) (dups,[]) fds return (dups0, Ctr cid fds) MAT -> do let loc = termLoc term let ari = termLab term val <- got (loc + 0) css <- if ari == 0 then return [] else mapM (\i -> got (loc + 1 + i)) [0..ari-1] (dups0, val0) <- extractCore val dups (dups1, css0) <- foldM (\ (dups,css) cs -> do (dups0, cs0) <- extractCore cs dups return (dups0, css ++ [cs0])) (dups0,[]) css return (dups1, Mat val0 css0) REF -> do let loc = termLoc term return (dups, Ref "?" loc) _ -> do return (dups, Era) #187: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #188: -- //./Type.hs// #189: module HVML.Inject where #190: import Control.Monad (foldM) import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #191: type VarMap = IM.IntMap (Maybe Term) #192: injectCore :: Book -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore book (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore book bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore book (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore book fun (app + 0) vars vars1 <- injectCore book arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore book (Sup lab tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore book tm0 (sup + 0) vars vars1 <- injectCore book tm1 (sup + 1) vars0 set loc (termNew _SUP_ lab sup) return vars1 injectCore book (Dup lab dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ lab dup) vars vars1 <- injectBind dp1 (termNew _DP1_ lab dup) vars0 vars2 <- injectCore book val (dup + 2) vars1 injectCore book bod loc vars2 injectCore book (Ref nam fid) loc vars = do set loc (termNew _REF_ 0 fid) return vars injectCore book (Ctr cid fds) loc vars = do let arity = length fds ctr <- allocNode (fromIntegral arity) vars0 <- foldM (\vs (ix,fd) -> injectCore book fd (ctr + ix) vs) vars (zip [0..] fds) set loc (termNew _CTR_ (u12v2New cid (fromIntegral (length fds))) ctr) return vars0 injectCore book (Mat val css) loc vars = do mat <- allocNode (1 + fromIntegral (length css)) vars0 <- injectCore book val (mat + 0) vars vars1 <- foldM (\vs (ix,bod) -> do injectCore book bod (mat + 1 + ix) vs) vars0 (zip [0..] css) set loc (termNew _MAT_ (fromIntegral (length css)) mat) return vars1 injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #193: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #194: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do injectCore book core 0 IM.empty got 0

b9a7df8056de9294a8f2ce6fe9cae8b5ba071614

modes: run (Haskell) / run-c (C)

./Show.hs #1: module HVML.Show where #2: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #3: -- Core Stringification -- -------------------- #4: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup tm0 tm1) = "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup dp0 dp1 val bod) = "&{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod #5: -- Runtime Stringification -- ----------------------- #6: tagToString :: Tag -> String tagToString t = show (tagT t) #7: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #8: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #9: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #10: -- Dumping -- ------- #11: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #12: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #13: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #14: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #15: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #16: -- //./Type.hs// #17: module HVML.Parse where #18: import HVML.Type import Text.Parsec hiding (State) import Text.Parsec.String import qualified Data.Map.Strict as MS #19: parseCore :: Parser Core parseCore = do spaces head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '{' -> do consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup tm0 tm1 '&' -> do consume "&" consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam _ -> do name <- parseName return $ Var name #20: parseName :: Parser String parseName = spaces >> many1 (alphaNum <|> char '_') #21: parseDef :: Parser (String, Core) parseDef = do try $ do spaces consume "@" name <- parseName spaces consume "=" core <- parseCore return (name, core) #22: parseBook :: Parser Book parseBook = do spaces defs <- many parseDef return $ MS.fromList defs #23: doParseCore :: String -> Core doParseCore code = case parse parseCore "" code of Right core -> core Left _ -> Era #24: doParseBook :: String -> Book doParseBook code = case parse parseBook "" code of Right book -> book Left _ -> MS.empty #25: consume :: String -> Parser String consume str = spaces >> string str ./Compile.hs #26: -- //./Type.hs// #27: module HVML.Compile where #28: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #29: -- Book IDs -- -------- #30: genBookIds :: Book -> MS.Map String Word64 genBookIds book = MS.fromList $ zip (MS.keys book) [0..] #31: -- Compilation -- ----------- #32: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #33: type Compile = State CompileState #34: compile :: Book -> String -> Core -> String compile book name core = unlines [ "Term F_" ++ name ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where fids = genBookIds book (result, st) = runState (compileCore fids core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #35: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #36: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #37: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #38: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #39: compileCore :: MS.Map String Word64 -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore fids (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore fids bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore fids (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore fids fun (appName ++ " + 0") argT <- compileCore fids arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore fids (Sup tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore fids tm0 (supName ++ " + 0") tm1T <- compileCore fids tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, 0, " ++ supName ++ ")" compileCore fids (Dup dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, 0, " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, 0, " ++ dupName ++ " + 0)" valT <- compileCore fids val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore fids bod host return bodT compileCore fids (Ref name) _ = return $ "term_new(REF, 0, " ++ show (MS.findWithDefault 0 name fids) ++ ")" ./Main.hs #40: -- Type.hs: -- //./Type.hs// -- Compile.hs: -- //./Compile.hs// -- Runtime.c: -- //./Runtime.c// -- Main.hs: #41: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #42: module Main where #43: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #44: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Normal import HVML.Parse import HVML.Show import HVML.Type #45: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #46: -- Main -- ---- #47: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file True ["run", file] -> cliRun file False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #48: -- CLI Commands -- ------------ #49: cliRun :: FilePath -> Bool -> IO (Either String ()) cliRun filePath showStats = do -- Initialize the HVM hvmInit #50: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath let book = doParseBook code #51: -- Create the C file content let funcs = map (\ (name, core) -> compile book name core) (MS.toList book) let bookC = unlines $ [runtime_c] ++ funcs let fids = genBookIds book #52: -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #53: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #54: -- Set the book's HVM pointers hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- For each function in the book, get its function pointer and register it forM_ (MS.keys book) $ \ name -> do funPtr <- dlsym bookLib ("F_" ++ name) hvmDefine (fromIntegral (MS.findWithDefault 0 name fids)) funPtr -- print ("defined " ++ name) #55: -- Normalize main init <- getCPUTime root <- doInjectCore fids (Ref "main") norm <- normal root core <- doExtractCore norm putStrLn $ coreToString core #56: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #57: -- Finalize hvmFree return $ Right () #58: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Normal.hs #59: module HVML.Normal where #60: import HVML.Type #61: normal :: Term -> HVM Term normal term = do wnf <- reduce term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normal fun arg <- normal arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normal bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normal tm0 tm1 <- normal tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normal val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normal val set (loc + 2) val return wnf _ -> return wnf ./Type.hs #62: module HVML.Type where #63: import Data.Word import Data.Map.Strict as MS import Foreign.Ptr #64: -- Core Types -- ---------- #65: data Core = Var String | Era | Lam String Core | App Core Core | Sup Core Core | Dup String String Core Core | Ref String deriving (Show, Eq) #66: type Book = MS.Map String Core type Fids = MS.Map String Word64 #67: -- Runtime Types -- ------------- #68: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #69: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF deriving (Eq, Show) #70: type HVM = IO #71: -- C Functions -- ----------- #72: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #73: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #74: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #75: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #76: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #77: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #78: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #79: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #80: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #81: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #82: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #83: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #84: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #85: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #86: foreign import ccall unsafe "Runtime.c reduce" reduce :: Term -> IO Term #87: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #88: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #89: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #90: -- Constants -- --------- #91: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT tag = error $ "unknown tag" ++ show tag #92: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 ./Runtime.c #93: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #94: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint64_t u64; #95: typedef _Atomic(Term) ATerm; #96: // Runtime Types // ------------- #97: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #98: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #99: // Constants // --------- #100: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #101: #define VOID 0x00000000000000 #102: // Heap // ---- #103: Loc get_len() { return *HVM.size; } #104: Loc get_itr() { return *HVM.itrs; } #105: void set_len(Loc value) { *HVM.size = value; } #106: void set_itr(Loc value) { *HVM.itrs = value; } #107: // Terms // ------ #108: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #109: Tag term_tag(Term x) { return x & 0xFF; } #110: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #111: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #112: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #113: // Atomics // ------- #114: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #115: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #116: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #117: Term take(Loc loc) { return swap(loc, VOID); } #118: // Allocation // ---------- #119: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #120: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #121: // Stringification // --------------- #122: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; default : printf("???"); break; } } #123: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #124: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #125: // Evaluation // ---------- #126: // (* a) // ----- APP_ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #127: // (λx(body) a) // ------------ APP_LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #128: // ({a b} c) // --------------- APP_SUP // & {x0 x1} = c // {(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, 0, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, 0, su0); } #129: // & {x y} = * // ----------- DUP_ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #130: // & {r s} = λx(f) // --------------- DUP_LAM // & {f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- {x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, 0, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, 0, su0)); return got(dup_loc + dup_num); } #131: // & {x y} = {a b} // --------------- DUP_SUP // x <- a // y <- b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } #132: Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #133: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("next: "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; default: break; } break; } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #134: //Term normal(Term term) { //Term wnf = reduce(term); //Tag tag = term_tag(wnf); //Lab lab = term_lab(wnf); //Loc loc = term_loc(wnf); //switch (tag) { //case APP: { //Term fun; //Term arg; //fun = got(loc + 0); //fun = normal(fun); //arg = got(loc + 1); //arg = normal(arg); //set(loc + 0, fun); //set(loc + 1, arg); //return wnf; //} //case LAM: { //Term bod; //bod = got(loc + 1); //bod = normal(bod); //set(loc + 1, bod); //return wnf; //} //case SUP: { //Term tm0; //Term tm1; //tm0 = got(loc + 0); //tm0 = normal(tm0); //tm1 = got(loc + 1); //tm1 = normal(tm1); //set(loc + 0, tm0); //set(loc + 1, tm1); //return wnf; //} //case DP0: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //case DP1: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //default: //return wnf; //} //} #135: // Runtime Memory // -------------- #136: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #137: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #138: // TODO: create an hvm_get and an hvm_set function that get/set the whole HVM struct State* hvm_get_state() { return &HVM; } #139: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #140: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #141: // Main // ---- #142: //#include "book.c" #143: //int main() { //hvm_init(); //inject_P24(); #144: //clock_t start = clock(); #145: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #146: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #147: //hvm_free(); //return 0; //} ./Extract.hs #148: module HVML.Extract where #149: import HVML.Type import qualified Data.IntSet as IS #150: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp1)) else extractCore sub dups REF -> do return (dups, Var "?") _ -> return (dups, Era) #151: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #152: -- //./Type.hs// #153: module HVML.Inject where #154: import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #155: type VarMap = IM.IntMap (Maybe Term) #156: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #157: injectCore :: Fids -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore fids (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore fids bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore fids (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore fids fun (app + 0) vars vars1 <- injectCore fids arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore fids (Sup tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore fids tm0 (sup + 0) vars vars1 <- injectCore fids tm1 (sup + 1) vars0 set loc (termNew _SUP_ 0 sup) return vars1 injectCore fids (Dup dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ 0 dup) vars vars1 <- injectBind dp1 (termNew _DP1_ 0 dup) vars0 vars2 <- injectCore fids val (dup + 2) vars1 injectCore fids bod loc vars2 injectCore fids (Ref nam) loc vars = do case MS.lookup nam fids of Just fid -> set loc (termNew _REF_ 0 fid) Nothing -> error $ "Undefined reference: " ++ nam return vars injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #158: doInjectCore :: Fids -> Core -> HVM Term doInjectCore fids core = do injectCore fids core 0 IM.empty got 0

./Show.hs #1: module HVML.Show where #2: import Data.Char (intToDigit) import Data.Word import HVML.Type import Numeric (showIntAtBase) #3: -- Core Stringification -- -------------------- #4: coreToString :: Core -> String coreToString (Var nam) = nam coreToString Era = "*" coreToString (Lam vr0 bod) = "λ" ++ vr0 ++ " " ++ coreToString bod coreToString (App fun arg) = "(" ++ coreToString fun ++ " " ++ coreToString arg ++ ")" coreToString (Sup tm0 tm1) = "{" ++ coreToString tm0 ++ " " ++ coreToString tm1 ++ "}" coreToString (Dup dp0 dp1 val bod) = "&{" ++ dp0 ++ " " ++ dp1 ++ "} = " ++ coreToString val ++ " " ++ coreToString bod coreToString (Ref nam fid) = "@" ++ nam #5: -- Runtime Stringification -- ----------------------- #6: tagToString :: Tag -> String tagToString t = show (tagT t) #7: labToString :: Word64 -> String labToString loc = padLeft (showHex loc) 6 '0' #8: locToString :: Word64 -> String locToString loc = padLeft (showHex loc) 9 '0' #9: termToString :: Term -> String termToString term = let tag = tagToString (termTag term) lab = labToString (termLab term) loc = locToString (termLoc term) in "term_new(" ++ tag ++ ",0x" ++ lab ++ ",0x" ++ loc ++ ")" #10: -- Dumping -- ------- #11: dumpHeapRange :: Word64 -> Word64 -> HVM [(Word64, Term)] dumpHeapRange ini len = if ini < len then do head <- got ini tail <- dumpHeapRange (ini + 1) len if head == 0 then return tail else return ((ini, head) : tail) else return [] #12: dumpHeap :: HVM ([(Word64, Term)], Word64) dumpHeap = do len <- getLen itr <- getItr terms <- dumpHeapRange 0 len return (terms, itr) #13: heapToString :: ([(Word64, Term)], Word64) -> String heapToString (terms, itr) = "set_itr(0x" ++ padLeft (showHex itr) 9 '0' ++ ");\n" ++ foldr (\(k,v) txt -> let addr = padLeft (showHex k) 9 '0' term = termToString v in "set(0x" ++ addr ++ ", " ++ term ++ ");\n" ++ txt) "" terms #14: padLeft :: String -> Int -> Char -> String padLeft str n c = replicate (n - length str) c ++ str #15: showHex :: Word64 -> String showHex x = showIntAtBase 16 intToDigit (fromIntegral x) "" ./Parse.hs #16: -- //./Type.hs// #17: module HVML.Parse where #18: import HVML.Type import Text.Parsec hiding (State) import Text.Parsec.String import qualified Data.Map.Strict as MS import Data.Word #19: parseCore :: Parser Core parseCore = do spaces head <- lookAhead anyChar case head of '*' -> do consume "*" return Era 'λ' -> do consume "λ" vr0 <- parseName bod <- parseCore return $ Lam vr0 bod '(' -> do consume "(" fun <- parseCore arg <- parseCore consume ")" return $ App fun arg '{' -> do consume "{" tm0 <- parseCore tm1 <- parseCore consume "}" return $ Sup tm0 tm1 '&' -> do consume "&" consume "{" dp0 <- parseName dp1 <- parseName consume "}" consume "=" val <- parseCore bod <- parseCore return $ Dup dp0 dp1 val bod '@' -> do consume "@" nam <- parseName return $ Ref nam 0 _ -> do name <- parseName return $ Var name #20: parseName :: Parser String parseName = spaces >> many1 (alphaNum <|> char '_') #21: parseDef :: Parser (String, Core) parseDef = do try $ do spaces consume "@" name <- parseName spaces consume "=" core <- parseCore return (name, core) #22: parseBook :: Parser [(String, Core)] parseBook = do spaces many parseDef #23: doParseCore :: String -> Core doParseCore code = case parse parseCore "" code of Right core -> core Left _ -> Era #24: doParseBook :: String -> Book doParseBook code = case parse parseBook "" code of Right defs -> createBook defs Left _ -> Book MS.empty MS.empty MS.empty #25: consume :: String -> Parser String consume str = spaces >> string str #26: createBook :: [(String, Core)] -> Book createBook defs = let nameToId' = MS.fromList $ zip (map fst defs) [0..] idToName' = MS.fromList $ map (\(k,v) -> (v,k)) $ MS.toList nameToId' decorDefs = map (\ (name, core) -> (nameToId' MS.! name, decorateFnIds nameToId' core)) defs idToCore' = MS.fromList decorDefs in Book idToCore' idToName' nameToId' #27: decorateFnIds :: MS.Map String Word64 -> Core -> Core decorateFnIds fids term = case term of Ref nam _ -> Ref nam (fids MS.! nam) Lam x bod -> Lam x (decorateFnIds fids bod) App f x -> App (decorateFnIds fids f) (decorateFnIds fids x) Sup x y -> Sup (decorateFnIds fids x) (decorateFnIds fids y) Dup x y v b -> Dup x y (decorateFnIds fids v) (decorateFnIds fids b) other -> other ./Compile.hs #28: -- //./Type.hs// #29: module HVML.Compile where #30: import Control.Monad.State import Data.Word import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #31: -- Compilation -- ----------- #32: data CompileState = CompileState { next :: Word64 , args :: MS.Map String String -- var_name => binder_host , vars :: [(String, String)] -- [(var_name, var_host)] , code :: [String] } #33: type Compile = State CompileState #34: compile :: Book -> Word64 -> Core -> String compile book fid core = unlines [ "Term F_" ++ show fid ++ "() {" -- , " printf(\"calling " ++ name ++ "\\n\");" , unlines (reverse (varLines ++ code st)) , " return " ++ result ++ ";" , "}" ] where (result, st) = runState (compileCore book core "root") $ CompileState 0 MS.empty [] [] varLines = map makeVarLine (vars st) makeVarLine = \ (var, host) -> " set(" ++ host ++ ", " ++ (MS.findWithDefault "?" var (args st)) ++ ");" #35: emit :: String -> Compile () emit line = modify $ \s -> s { code = line : code s } #36: fresh :: Compile Word64 fresh = do uid <- gets next modify $ \s -> s { next = uid + 1 } return uid #37: bind :: String -> String -> Compile () bind var host = modify $ \s -> s { args = MS.insert var host (args s) } #38: addVar :: String -> String -> Compile () addVar var host = modify $ \s -> s { vars = (var, host) : vars s } #39: compileCore :: Book -> Core -> String -> Compile String compileCore _ Era _ = return $ "term_new(ERA, 0, 0)" compileCore _ (Var name) host = do addVar name host return $ "0" -- placeholder, will be set later compileCore book (Lam var bod) host = do uid <- fresh let lamName = "lam" ++ show uid emit $ " Loc " ++ lamName ++ " = alloc_node(2);" emit $ " set(" ++ lamName ++ " + 0, term_new(SUB, 0, 0));" bind var $ "term_new(VAR, 0, " ++ lamName ++ " + 0)" bodT <- compileCore book bod (lamName ++ " + 1") emit $ " set(" ++ lamName ++ " + 1, " ++ bodT ++ ");" return $ "term_new(LAM, 0, " ++ lamName ++ ")" compileCore book (App fun arg) host = do uid <- fresh let appName = "app" ++ show uid emit $ " Loc " ++ appName ++ " = alloc_node(2);" funT <- compileCore book fun (appName ++ " + 0") argT <- compileCore book arg (appName ++ " + 1") emit $ " set(" ++ appName ++ " + 0, " ++ funT ++ ");" emit $ " set(" ++ appName ++ " + 1, " ++ argT ++ ");" return $ "term_new(APP, 0, " ++ appName ++ ")" compileCore book (Sup tm0 tm1) host = do uid <- fresh let supName = "sup" ++ show uid emit $ " Loc " ++ supName ++ " = alloc_node(2);" tm0T <- compileCore book tm0 (supName ++ " + 0") tm1T <- compileCore book tm1 (supName ++ " + 1") emit $ " set(" ++ supName ++ " + 0, " ++ tm0T ++ ");" emit $ " set(" ++ supName ++ " + 1, " ++ tm1T ++ ");" return $ "term_new(SUP, 0, " ++ supName ++ ")" compileCore book (Dup dp0 dp1 val bod) host = do uid <- fresh let dupName = "dup" ++ show uid emit $ " Loc " ++ dupName ++ " = alloc_node(3);" emit $ " set(" ++ dupName ++ " + 0, term_new(SUB, 0, 0));" emit $ " set(" ++ dupName ++ " + 1, term_new(SUB, 0, 0));" bind dp0 $ "term_new(DP0, 0, " ++ dupName ++ " + 0)" bind dp1 $ "term_new(DP1, 0, " ++ dupName ++ " + 0)" valT <- compileCore book val (dupName ++ " + 2") emit $ " set(" ++ dupName ++ " + 2, " ++ valT ++ ");" bodT <- compileCore book bod host return bodT compileCore book (Ref nam fid) _ = return $ "term_new(REF, 0, " ++ show fid ++ ")" ./Main.hs #40: -- Type.hs: -- //./Type.hs// #41: {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} #42: module Main where #43: import Control.Monad (when, forM_) import Data.FileEmbed import Foreign.C.Types import Foreign.LibFFI import Foreign.LibFFI.Types import System.CPUTime import System.Environment (getArgs) import System.Exit (exitWith, ExitCode(ExitSuccess, ExitFailure)) import System.IO import System.IO (readFile) import System.Posix.DynamicLinker import System.Process (callCommand) import qualified Data.Map.Strict as MS #44: import HVML.Compile import HVML.Extract import HVML.Inject import HVML.Normal import HVML.Parse import HVML.Show import HVML.Type #45: runtime_c :: String runtime_c = $(embedStringFile "./src/HVML/Runtime.c") #46: -- Main -- ---- #47: main :: IO () main = do args <- getArgs result <- case args of ["run", file, "-s"] -> cliRun file False True ["run", file] -> cliRun file False False ["run-c", file, "-s"] -> cliRun file True True ["run-c", file] -> cliRun file True False ["help"] -> printHelp _ -> printHelp case result of Left err -> do putStrLn err exitWith (ExitFailure 1) Right _ -> do exitWith ExitSuccess #48: -- CLI Commands -- ------------ #49: cliRun :: FilePath -> Bool -> Bool -> IO (Either String ()) cliRun filePath compiled showStats = do -- Initialize the HVM hvmInit #50: -- TASK: instead of parsing a core term out of the file, lets parse a Book. code <- readFile filePath let book = doParseBook code #51: -- Create the C file content let funcs = map (\ (fid, core) -> compile book fid core) (MS.toList (idToCore book)) let bookC = unlines $ [runtime_c] ++ funcs #52: -- Compile to native when compiled $ do -- Write the C file writeFile "./.hvm_book.c" bookC -- Compile to shared library callCommand "gcc -O2 -fPIC -shared .hvm_book.c -o .hvm_book.so" -- Load the dynamic library bookLib <- dlopen "./.hvm_book.so" [RTLD_NOW] #53: -- Remove both generated files callCommand "rm .hvm_book.c .hvm_book.so" #54: -- Link compiled state hvmGotState <- hvmGetState hvmSetState <- dlsym bookLib "hvm_set_state" callFFI hvmSetState retVoid [argPtr hvmGotState] -- Register compiled functions forM_ (MS.keys (idToCore book)) $ \ fid -> do funPtr <- dlsym bookLib ("F_" ++ show fid) hvmDefine fid funPtr #55: -- Normalize main init <- getCPUTime root <- doInjectCore book (Ref "main" $ nameToId book MS.! "main") norm <- (if compiled then normalC else normal) book root >>= doExtractCore putStrLn $ coreToString norm #56: -- Show stats when showStats $ do end <- getCPUTime itr <- getItr len <- getLen let diff = fromIntegral (end - init) / (10^9) :: Double let mips = (fromIntegral itr / 1000000.0) / (diff / 1000.0) putStrLn $ "ITRS: " ++ show itr putStrLn $ "TIME: " ++ show diff ++ "ms" putStrLn $ "SIZE: " ++ show len putStrLn $ "MIPS: " ++ show mips return () #57: -- Finalize hvmFree return $ Right () #58: printHelp :: IO (Either String ()) printHelp = do putStrLn "HVM-Lazy usage:" putStrLn " hvml run [-s] <file> # Normalizes the specified file" putStrLn " hvml help # Shows this help message" return $ Right () ./Normal.hs #59: -- //./Runtime.c// -- //./Type.hs// #60: module HVML.Normal where #61: import Data.Word import HVML.Inject import HVML.Show import HVML.Type import qualified Data.Map.Strict as MS #62: debug a b = b #63: reduce :: Book -> Term -> HVM Term reduce book term = debug ("NEXT: " ++ termToString term) $ do let tag = termTag term lab = termLab term loc = termLoc term case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) reduceApp book lab loc fun arg DP0 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do dp0 <- got (loc + 0) dp1 <- got (loc + 1) val <- got (loc + 2) reduceDup book 0 lab loc dp0 dp1 val else reduce book sub DP1 -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then do dp0 <- got (loc + 0) dp1 <- got (loc + 1) val <- got (loc + 2) reduceDup book 1 lab loc dp0 dp1 val else reduce book sub VAR -> do sub <- got (loc + 0) if termTag sub == _SUB_ then return $ termNew (termTag term) lab loc else reduce book sub REF -> do let fid = termLoc term case MS.lookup fid (idToCore book) of Just core -> do core <- doInjectCore book core reduce book core Nothing -> return term _ -> return term #64: reduceApp :: Book -> Word64 -> Word64 -> Term -> Term -> HVM Term reduceApp book lab loc fun arg = do fun <- reduce book fun let funTag = termTag fun funLab = termLab fun funLoc = termLoc fun case tagT funTag of ERA -> debug "APP-ERA" $ do incItr return fun LAM -> debug "APP-LAM" $ do incItr bod <- got (funLoc + 1) set (funLoc + 0) arg set (loc + 0) 0 set (loc + 1) 0 set (funLoc + 1) 0 reduce book bod SUP -> debug "APP-SUP" $ do incItr tm0 <- got (funLoc + 0) tm1 <- got (funLoc + 1) du0 <- allocNode 3 su0 <- allocNode 2 ap0 <- allocNode 2 ap1 <- allocNode 2 set (du0 + 0) (termNew _SUB_ 0 0) set (du0 + 1) (termNew _SUB_ 0 0) set (du0 + 2) (termNew _ERA_ 0 7) set (du0 + 2) arg set (ap0 + 0) tm0 set (ap0 + 1) (termNew _DP0_ 0 du0) set (ap1 + 0) tm1 set (ap1 + 1) (termNew _DP1_ 0 du0) set (su0 + 0) (termNew _APP_ 0 ap0) set (su0 + 1) (termNew _APP_ 0 ap1) set (loc + 0) 0 set (loc + 1) 0 set (funLoc + 0) 0 set (funLoc + 1) 0 return $ termNew _SUP_ 0 su0 _ -> do set (loc + 0) fun return $ termNew _APP_ lab loc #65: reduceDup :: Book -> Word64 -> Word64 -> Word64 -> Term -> Term -> Term -> HVM Term reduceDup book n lab loc dp0 dp1 val = do val <- reduce book val let valTag = termTag val valLab = termLab val valLoc = termLoc val case tagT valTag of ERA -> debug "DUP-ERA" $ do incItr set (loc + 0) val set (loc + 1) val set (loc + 2) 0 got (loc + n) LAM -> debug "DUP-LAM" $ do incItr let vr0 = valLoc + 0 bod <- got (valLoc + 1) du0 <- allocNode 3 lm0 <- allocNode 2 lm1 <- allocNode 2 su0 <- allocNode 2 set (du0 + 0) (termNew _SUB_ 0 0) set (du0 + 1) (termNew _SUB_ 0 0) set (du0 + 2) bod set (lm0 + 0) (termNew _SUB_ 0 0) set (lm0 + 1) (termNew _DP0_ 0 du0) set (lm1 + 0) (termNew _SUB_ 0 0) set (lm1 + 1) (termNew _DP1_ 0 du0) set (su0 + 0) (termNew _VAR_ 0 lm0) set (su0 + 1) (termNew _VAR_ 0 lm1) set (loc + 0) (termNew _LAM_ 0 lm0) set (loc + 1) (termNew _LAM_ 0 lm1) set (vr0 + 0) (termNew _SUP_ 0 su0) set (loc + 2) 0 set (valLoc + 1) 0 got (loc + n) >>= reduce book SUP -> debug "DUP-SUP" $ do incItr tm0 <- got (valLoc + 0) tm1 <- got (valLoc + 1) set (loc + 0) tm0 set (loc + 1) tm1 set (loc + 2) 0 set (valLoc + 0) 0 set (valLoc + 1) 0 got (loc + n) >>= reduce book _ -> do set (loc + 2) val return $ termNew (if n == 0 then _DP0_ else _DP1_) lab loc #66: normalizer :: (Book -> Term -> HVM Term) -> Book -> Term -> HVM Term normalizer reducer book term = do wnf <- reducer book term let tag = termTag wnf lab = termLab wnf loc = termLoc wnf case tagT tag of APP -> do fun <- got (loc + 0) arg <- got (loc + 1) fun <- normalizer reducer book fun arg <- normalizer reducer book arg set (loc + 0) fun set (loc + 1) arg return wnf LAM -> do bod <- got (loc + 1) bod <- normalizer reducer book bod set (loc + 1) bod return wnf SUP -> do tm0 <- got (loc + 0) tm1 <- got (loc + 1) tm0 <- normalizer reducer book tm0 tm1 <- normalizer reducer book tm1 set (loc + 0) tm0 set (loc + 1) tm1 return wnf DP0 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf DP1 -> do val <- got (loc + 2) val <- normalizer reducer book val set (loc + 2) val return wnf _ -> do return wnf #67: normal :: Book -> Term -> HVM Term normal = normalizer reduce #68: normalC :: Book -> Term -> HVM Term normalC = normalizer (\ book -> reduceC) ./Type.hs #69: module HVML.Type where #70: import Data.Word import Data.Map.Strict as MS import Foreign.Ptr #71: -- Core Types -- ---------- #72: data Core = Var String | Era | Lam String Core | App Core Core | Sup Core Core | Dup String String Core Core | Ref String Word64 deriving (Show, Eq) #73: -- NOTE: the Book type has been refactored from: -- type Book = MS.Map String Core -- To: #74: type IdToCore = MS.Map Word64 Core type IdToName = MS.Map Word64 String type NameToId = MS.Map String Word64 #75: data Book = Book { idToCore :: IdToCore , idToName :: IdToName , nameToId :: NameToId } deriving (Show, Eq) #76: -- Updating all files will be necessary to reflect this change. #77: -- Runtime Types -- ------------- #78: type Tag = Word64 type Lab = Word64 type Loc = Word64 type Term = Word64 #79: data TAG = DP0 | DP1 | VAR | APP | ERA | LAM | SUP | SUB | REF deriving (Eq, Show) #80: type HVM = IO #81: -- C Functions -- ----------- #82: foreign import ccall unsafe "Runtime.c hvm_init" hvmInit :: IO () #83: foreign import ccall unsafe "Runtime.c hvm_free" hvmFree :: IO () #84: foreign import ccall unsafe "Runtime.c alloc_node" allocNode :: Word64 -> IO Word64 #85: foreign import ccall unsafe "Runtime.c set" set :: Word64 -> Term -> IO () #86: foreign import ccall unsafe "Runtime.c got" got :: Word64 -> IO Term #87: foreign import ccall unsafe "Runtime.c take" take :: Word64 -> IO Term #88: foreign import ccall unsafe "Runtime.c term_new" termNew :: Tag -> Lab -> Loc -> Term #89: foreign import ccall unsafe "Runtime.c term_tag" termTag :: Term -> Tag #90: foreign import ccall unsafe "Runtime.c term_lab" termLab :: Term -> Lab #91: foreign import ccall unsafe "Runtime.c term_loc" termLoc :: Term -> Loc #92: foreign import ccall unsafe "Runtime.c term_key" termKey :: Term -> Loc #93: foreign import ccall unsafe "Runtime.c get_len" getLen :: IO Word64 #94: foreign import ccall unsafe "Runtime.c get_itr" getItr :: IO Word64 #95: foreign import ccall unsafe "Runtime.c inc_itr" incItr :: IO Word64 #96: foreign import ccall unsafe "Runtime.c reduce" reduceC :: Term -> IO Term #97: foreign import ccall unsafe "Runtime.c hvm_define" hvmDefine :: Word64 -> FunPtr (IO Term) -> IO () #98: foreign import ccall unsafe "Runtime.c hvm_get_state" hvmGetState :: IO (Ptr ()) #99: foreign import ccall unsafe "Runtime.c hvm_set_state" hvmSetState :: Ptr () -> IO () #100: -- Constants -- --------- #101: tagT :: Tag -> TAG tagT 0x00 = DP0 tagT 0x01 = DP1 tagT 0x02 = VAR tagT 0x03 = APP tagT 0x04 = ERA tagT 0x05 = LAM tagT 0x06 = SUP tagT 0x07 = SUB tagT 0x08 = REF tagT tag = error $ "unknown tag" ++ show tag #102: _DP0_, _DP1_, _VAR_, _APP_, _ERA_, _LAM_, _SUP_, _SUB_, _REF_ :: Tag _DP0_ = 0x00 _DP1_ = 0x01 _VAR_ = 0x02 _APP_ = 0x03 _ERA_ = 0x04 _LAM_ = 0x05 _SUP_ = 0x06 _SUB_ = 0x07 _REF_ = 0x08 ./Runtime.c #103: #include <stdatomic.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <sys/mman.h> #include <time.h> #104: typedef uint8_t Tag; typedef uint32_t Lab; typedef uint32_t Loc; typedef uint64_t Term; typedef uint64_t u64; #105: typedef _Atomic(Term) ATerm; #106: // Runtime Types // ------------- #107: // Global State Type typedef struct { Term* path; // reduction path / stack ATerm* heap; // global node buffer u64* size; // global node length u64* itrs; // interaction count Term (*book[1024])(); // functions } State; #108: // Global State Value static State HVM = { .path = NULL, .heap = NULL, .size = NULL, .itrs = NULL, .book = {NULL} }; #109: // Constants // --------- #110: #define DP0 0x00 #define DP1 0x01 #define VAR 0x02 #define APP 0x03 #define ERA 0x04 #define LAM 0x05 #define SUP 0x06 #define SUB 0x07 #define REF 0x08 #111: #define VOID 0x00000000000000 #112: // Heap // ---- #113: Loc get_len() { return *HVM.size; } #114: Loc get_itr() { return *HVM.itrs; } #115: void set_len(Loc value) { *HVM.size = value; } #116: void set_itr(Loc value) { *HVM.itrs = value; } #117: // Terms // ------ #118: Term term_new(Tag tag, Lab lab, Loc loc) { Term tag_enc = tag; Term lab_enc = ((Term)lab) << 8; Term loc_enc = ((Term)loc) << 32; return tag_enc | lab_enc | loc_enc; } #119: Tag term_tag(Term x) { return x & 0xFF; } #120: Lab term_lab(Term x) { return (x >> 8) & 0xFFFFFF; } #121: Loc term_loc(Term x) { return (x >> 32) & 0xFFFFFFFF; } #122: Loc term_key(Term term) { switch (term_tag(term)) { case VAR: return term_loc(term) + 0; case DP0: return term_loc(term) + 0; case DP1: return term_loc(term) + 1; default: return 0; } } #123: // Atomics // ------- #124: Term swap(Loc loc, Term term) { return atomic_exchange_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #125: Term got(Loc loc) { return atomic_load_explicit(&HVM.heap[loc], memory_order_relaxed); } #126: void set(Loc loc, Term term) { atomic_store_explicit(&HVM.heap[loc], term, memory_order_relaxed); } #127: Term take(Loc loc) { return swap(loc, VOID); } #128: // Allocation // ---------- #129: Loc alloc_node(Loc arity) { u64 old = *HVM.size; *HVM.size += arity; return old; } #130: Loc inc_itr() { u64 old = *HVM.itrs; *HVM.itrs += 1; return old; } #131: // Stringification // --------------- #132: void print_tag(Tag tag) { switch (tag) { case SUB: printf("SUB"); break; case VAR: printf("VAR"); break; case DP0: printf("DP0"); break; case DP1: printf("DP1"); break; case APP: printf("APP"); break; case ERA: printf("ERA"); break; case LAM: printf("LAM"); break; case SUP: printf("SUP"); break; case REF: printf("REF"); break; default : printf("???"); break; } } #133: void print_term(Term term) { printf("term_new("); print_tag(term_tag(term)); printf(",0x%06x,0x%09x)", term_lab(term), term_loc(term)); } #134: void print_heap() { Loc len = get_len(); for (Loc i = 0; i < len; i++) { Term term = got(i); if (term != 0) { printf("set(0x%09x, ", i); print_term(term); printf(");\n"); } } } #135: // Evaluation // ---------- #136: // (* a) // ----- APP_ERA // * Term reduce_app_era(Term app, Term era) { inc_itr(); return era; } #137: // (λx(body) a) // ------------ APP_LAM // x <- a // body Term reduce_app_lam(Term app, Term lam) { inc_itr(); Loc app_loc = term_loc(app); Loc lam_loc = term_loc(lam); Term arg = got(app_loc + 1); Term bod = got(lam_loc + 1); set(lam_loc + 0, arg); return bod; } #138: // ({a b} c) // --------------- APP_SUP // & {x0 x1} = c // {(a x0) (b x1)} Term reduce_app_sup(Term app, Term sup) { inc_itr(); Loc app_loc = term_loc(app); Loc sup_loc = term_loc(sup); Term arg = got(app_loc + 1); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); Loc du0 = alloc_node(3); Loc su0 = alloc_node(2); Loc ap0 = alloc_node(2); Loc ap1 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, arg); set(ap0 + 0, tm0); set(ap0 + 1, term_new(DP0, 0, du0)); set(ap1 + 0, tm1); set(ap1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(APP, 0, ap0)); set(su0 + 1, term_new(APP, 0, ap1)); return term_new(SUP, 0, su0); } #139: // & {x y} = * // ----------- DUP_ERA // x <- * // y <- * Term reduce_dup_era(Term dup, Term era) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; set(dup_loc + 0, era); set(dup_loc + 1, era); return got(dup_loc + dup_num); } #140: // & {r s} = λx(f) // --------------- DUP_LAM // & {f0 f1} = f // r <- λx0(f0) // s <- λx1(f1) // x <- {x0 x1} Term reduce_dup_lam(Term dup, Term lam) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc lam_loc = term_loc(lam); Term bod = got(lam_loc + 1); Loc du0 = alloc_node(3); Loc lm0 = alloc_node(2); Loc lm1 = alloc_node(2); Loc su0 = alloc_node(2); set(du0 + 0, term_new(SUB, 0, 0)); set(du0 + 1, term_new(SUB, 0, 0)); set(du0 + 2, bod); set(lm0 + 0, term_new(SUB, 0, 0)); set(lm0 + 1, term_new(DP0, 0, du0)); set(lm1 + 0, term_new(SUB, 0, 0)); set(lm1 + 1, term_new(DP1, 0, du0)); set(su0 + 0, term_new(VAR, 0, lm0)); set(su0 + 1, term_new(VAR, 0, lm1)); set(dup_loc + 0, term_new(LAM, 0, lm0)); set(dup_loc + 1, term_new(LAM, 0, lm1)); set(lam_loc + 0, term_new(SUP, 0, su0)); return got(dup_loc + dup_num); } #141: // & {x y} = {a b} // --------------- DUP_SUP // x <- a // y <- b Term reduce_dup_sup(Term dup, Term sup) { inc_itr(); Loc dup_loc = term_loc(dup); Tag dup_num = term_tag(dup) == DP0 ? 0 : 1; Loc sup_loc = term_loc(sup); Term tm0 = got(sup_loc + 0); Term tm1 = got(sup_loc + 1); set(dup_loc + 0, tm0); set(dup_loc + 1, tm1); return got(dup_loc + dup_num); } #142: Term reduce_ref(Term ref) { inc_itr(); return HVM.book[term_loc(ref)](); } #143: Term reduce(Term term) { //printf("reduce\n"); Loc spos = 0; Term next = term; while (1) { //printf("next: "); print_term(next); printf("\n"); Tag tag = term_tag(next); Lab lab = term_lab(next); Loc loc = term_loc(next); switch (tag) { case APP: { HVM.path[spos++] = next; next = got(loc + 0); continue; } case DP0: case DP1: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { HVM.path[spos++] = next; next = got(loc + 2); continue; } else { next = sub; continue; } } case VAR: { Loc key = term_key(next); Term sub = got(key); if (term_tag(sub) == SUB) { break; } else { next = sub; continue; } } case REF: { next = reduce_ref(next); continue; } default: { if (spos == 0) { break; } else { Term prev = HVM.path[--spos]; Tag ptag = term_tag(prev); Lab plab = term_lab(prev); Loc ploc = term_loc(prev); switch (ptag) { case APP: { switch (tag) { case ERA: next = reduce_app_era(prev, next); continue; case LAM: next = reduce_app_lam(prev, next); continue; case SUP: next = reduce_app_sup(prev, next); continue; default: break; } break; } case DP0: case DP1: { switch (tag) { case ERA: next = reduce_dup_era(prev, next); continue; case LAM: next = reduce_dup_lam(prev, next); continue; case SUP: next = reduce_dup_sup(prev, next); continue; default: break; } break; } default: break; } break; } } } if (spos == 0) { //printf("retr: "); print_term(next); printf("\n"); return next; } else { Term host = HVM.path[--spos]; Tag htag = term_tag(host); Lab hlab = term_lab(host); Loc hloc = term_loc(host); switch (htag) { case APP: set(hloc + 0, next); break; case DP0: set(hloc + 2, next); break; case DP1: set(hloc + 2, next); break; } return HVM.path[0]; } } printf("retr: ERR\n"); return 0; } #144: //Term normal(Term term) { //Term wnf = reduce(term); //Tag tag = term_tag(wnf); //Lab lab = term_lab(wnf); //Loc loc = term_loc(wnf); //switch (tag) { //case APP: { //Term fun; //Term arg; //fun = got(loc + 0); //fun = normal(fun); //arg = got(loc + 1); //arg = normal(arg); //set(loc + 0, fun); //set(loc + 1, arg); //return wnf; //} //case LAM: { //Term bod; //bod = got(loc + 1); //bod = normal(bod); //set(loc + 1, bod); //return wnf; //} //case SUP: { //Term tm0; //Term tm1; //tm0 = got(loc + 0); //tm0 = normal(tm0); //tm1 = got(loc + 1); //tm1 = normal(tm1); //set(loc + 0, tm0); //set(loc + 1, tm1); //return wnf; //} //case DP0: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //case DP1: { //Term val; //val = got(loc + 2); //val = normal(val); //set(loc + 2, val); //return wnf; //} //default: //return wnf; //} //} #145: // Runtime Memory // -------------- #146: void hvm_init() { // FIXME: use mmap instead HVM.path = malloc((1ULL << 32) * sizeof(Term)); HVM.heap = malloc((1ULL << 32) * sizeof(ATerm)); HVM.size = malloc(sizeof(u64)); HVM.itrs = malloc(sizeof(u64)); *HVM.size = 1; *HVM.itrs = 0; } #147: void hvm_free() { free(HVM.path); free(HVM.heap); free(HVM.size); free(HVM.itrs); } #148: // TODO: create an hvm_get and an hvm_set function that get/set the whole HVM struct State* hvm_get_state() { return &HVM; } #149: void hvm_set_state(State* hvm) { HVM.path = hvm->path; HVM.heap = hvm->heap; HVM.size = hvm->size; HVM.itrs = hvm->itrs; for (int i = 0; i < 1024; i++) { HVM.book[i] = hvm->book[i]; } } #150: void hvm_define(u64 fid, Term (*func)()) { HVM.book[fid] = func; } #151: // Main // ---- #152: //#include "book.c" #153: //int main() { //hvm_init(); //inject_P24(); #154: //clock_t start = clock(); #155: //// Normalize and get interaction count //Term root = got(0); //normal(root); //clock_t end = clock(); #156: //printf("Itrs: %u\n", get_itr()); //double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000; //printf("Size: %u nodes\n", get_len()); //printf("Time: %.2f seconds\n", time_spent / 1000.0); //printf("MIPS: %.2f\n", (get_itr() / 1000000.0) / (time_spent / 1000.0)); #157: //hvm_free(); //return 0; //} ./Extract.hs #158: module HVML.Extract where #159: import HVML.Type import qualified Data.IntSet as IS #160: extractCore :: Term -> IS.IntSet -> HVM (IS.IntSet, Core) extractCore term dups = case tagT (termTag term) of ERA -> return (dups, Era) LAM -> do let loc = termLoc term bod <- got (loc + 1) let var = show (loc + 0) (dups0, bod0) <- extractCore bod dups return (dups0, Lam var bod0) APP -> do let loc = termLoc term fun <- got (loc + 0) arg <- got (loc + 1) (dups0, fun0) <- extractCore fun dups (dups1, arg0) <- extractCore arg dups0 return (dups1, App fun0 arg0) SUP -> do let loc = termLoc term tm0 <- got (loc + 0) tm1 <- got (loc + 1) (dups0, tm00) <- extractCore tm0 dups (dups1, tm10) <- extractCore tm1 dups0 return (dups1, Sup tm00 tm10) VAR -> do let key = termKey term sub <- got key if termTag sub == _SUB_ then return (dups, Var (show key)) else extractCore sub dups DP0 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp0)) else extractCore sub dups DP1 -> do let loc = termLoc term let key = termKey term sub <- got key if termTag sub == _SUB_ then if IS.member (fromIntegral loc) dups then return (dups, Var (show key)) else do let dp0 = show (loc + 0) let dp1 = show (loc + 1) val <- got (loc + 2) (dups0, val0) <- extractCore val (IS.insert (fromIntegral loc) dups) return (dups0, Dup dp0 dp1 val0 (Var dp1)) else extractCore sub dups REF -> do let loc = termLoc term return (dups, Ref "?" loc) _ -> return (dups, Era) #161: doExtractCore :: Term -> HVM Core doExtractCore term = do (_, core) <- extractCore term IS.empty return core ./Inject.hs #162: -- //./Type.hs// #163: module HVML.Inject where #164: import Data.Word import HVML.Type import qualified Data.IntMap.Strict as IM import qualified Data.Map.Strict as MS #165: type VarMap = IM.IntMap (Maybe Term) #166: injectCore :: Book -> Core -> Word64 -> VarMap -> HVM VarMap injectCore _ Era loc vars = do set loc (termNew _ERA_ 0 0) return vars injectCore book (Lam vr0 bod) loc vars = do lam <- allocNode 2 vars0 <- injectBind vr0 (termNew _VAR_ 0 (lam + 0)) vars vars1 <- injectCore book bod (lam + 1) vars0 set loc (termNew _LAM_ 0 lam) return vars1 injectCore book (App fun arg) loc vars = do app <- allocNode 2 vars0 <- injectCore book fun (app + 0) vars vars1 <- injectCore book arg (app + 1) vars0 set loc (termNew _APP_ 0 app) return vars1 injectCore book (Sup tm0 tm1) loc vars = do sup <- allocNode 2 vars0 <- injectCore book tm0 (sup + 0) vars vars1 <- injectCore book tm1 (sup + 1) vars0 set loc (termNew _SUP_ 0 sup) return vars1 injectCore book (Dup dp0 dp1 val bod) loc vars = do dup <- allocNode 3 vars0 <- injectBind dp0 (termNew _DP0_ 0 dup) vars vars1 <- injectBind dp1 (termNew _DP1_ 0 dup) vars0 vars2 <- injectCore book val (dup + 2) vars1 injectCore book bod loc vars2 injectCore book (Ref nam fid) loc vars = do set loc (termNew _REF_ 0 fid) return vars injectCore _ (Var uid) loc vars = do let namHash = hash uid case IM.lookup namHash vars of Nothing -> return $ IM.insert namHash (Just loc) vars Just mOldVar -> case mOldVar of Nothing -> return $ IM.insert namHash (Just loc) vars Just oldVar -> do set loc oldVar return $ IM.insert namHash (Just loc) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #167: injectBind :: String -> Term -> VarMap -> HVM VarMap injectBind nam var vars = do let subKey = termKey var let namHash = hash nam case IM.lookup namHash vars of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just mOldVar -> case mOldVar of Nothing -> do set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars Just oldVar -> do set oldVar var set subKey (termNew _SUB_ 0 0) return $ IM.insert namHash (Just var) vars where hash :: String -> Int hash = foldl (\h c -> 33 * h + fromEnum c) 5381 #168: doInjectCore :: Book -> Core -> HVM Term doInjectCore book core = do injectCore book core 0 IM.empty got 0